--- /dev/null
+---
+Language: Cpp
+BasedOnStyle: Google
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: true
+AlignEscapedNewlinesLeft: true
+AlignOperands: true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: true
+AlwaysBreakTemplateDeclarations: true
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+ AfterClass: true
+ AfterControlStatement: true
+ AfterEnum: true
+ AfterFunction: true
+ AfterNamespace: true
+ AfterObjCDeclaration: false
+ AfterStruct: true
+ AfterUnion: true
+ BeforeCatch: false
+ BeforeElse: false
+ IndentBraces: false
+ SplitEmptyFunction: true
+ SplitEmptyRecord: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Allman
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+AllowAllConstructorInitializersOnNextLine : false
+ConstructorInitializerIndentWidth: 0
+ColumnLimit: 0
+CommentPragmas: '^ IWYU pragma:'
+ContinuationIndentWidth: 2
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat: false
+ExperimentalAutoDetectBinPacking: false
+ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
+IncludeBlocks: Preserve
+IncludeCategories:
+ - Regex: '^<.*\.h>'
+ Priority: 1
+ - Regex: '^<.*'
+ Priority: 2
+ - Regex: '.*'
+ Priority: 3
+SpaceBeforeCtorInitializerColon: false
+IndentCaseLabels: true
+IndentWidth: 2
+IndentWrappedFunctionNames: false
+KeepEmptyLinesAtTheStartOfBlocks: false
+MacroBlockBegin: '^DALI_ENUM_TO_STRING_TABLE_BEGIN'
+MacroBlockEnd: 'DALI_ENUM_TO_STRING_TABLE_END'
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PenaltyBreakBeforeFirstCallParameter: 1
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 200
+PointerAlignment: Left
+ReflowComments: true
+SortIncludes: true
+SpaceAfterCStyleCast: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: Never
+SpaceInEmptyParentheses: false
+SpacesInConditionalStatement : false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceAfterTemplateKeyword: false
+Standard: Auto
+TabWidth: 2
+UseTab: Never
+...
#include <stdio.h>
#include <stdlib.h>
-#define assert(exp) \
- if (!(exp)) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert(exp) \
+ if(!(exp)) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Following expression is not true:\n" \
- "%s\n", #exp); \
- return 1; \
- }
+ "%s\n", \
+ #exp); \
+ return 1; \
+ }
-#define assert_eq(var, ref) \
- if (var != ref) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert_eq(var, ref) \
+ if(var != ref) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Values \"%s\" and \"%s\" are not equal:\n" \
- "%s == %d, %s == %d\n", \
- #var, #ref, #var, (int)var, #ref, (int)ref); \
- return 1; \
- }
+ "%s == %d, %s == %d\n", \
+ #var, \
+ #ref, \
+ #var, \
+ (int)var, \
+ #ref, \
+ (int)ref); \
+ return 1; \
+ }
-#define assert_neq(var, ref) \
- if (var == ref) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert_neq(var, ref) \
+ if(var == ref) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Values \"%s\" and \"%s\" are equal:\n" \
- "%s == %s == %d\n", \
- #var, #ref, #var, #ref, (int)ref); \
- return 1; \
- }
+ "%s == %s == %d\n", \
+ #var, \
+ #ref, \
+ #var, \
+ #ref, \
+ (int)ref); \
+ return 1; \
+ }
-#define assert_gt(var, ref) \
- if (var <= ref) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert_gt(var, ref) \
+ if(var <= ref) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Value \"%s\" is not greater than \"%s\":\n" \
- "%s == %d, %s == %d\n", \
- #var, #ref, #var, var, #ref, ref); \
- return 1; \
- }
+ "%s == %d, %s == %d\n", \
+ #var, \
+ #ref, \
+ #var, \
+ var, \
+ #ref, \
+ ref); \
+ return 1; \
+ }
-#define assert_geq(var, ref) \
- if (var < ref) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert_geq(var, ref) \
+ if(var < ref) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Value \"%s\" is not greater or equal to \"%s\":\n" \
- "%s == %d, %s == %d\n", \
- #var, #ref, #var, var, #ref, ref); \
- return 1; \
- }
+ "%s == %d, %s == %d\n", \
+ #var, \
+ #ref, \
+ #var, \
+ var, \
+ #ref, \
+ ref); \
+ return 1; \
+ }
-#define assert_lt(var, ref) \
- if (var >= ref) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert_lt(var, ref) \
+ if(var >= ref) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Value \"%s\" is not lower than \"%s\":\n" \
- "%s == %d, %s == %d\n", \
- #var, #ref, #var, var, #ref, ref); \
- return 1; \
- }
+ "%s == %d, %s == %d\n", \
+ #var, \
+ #ref, \
+ #var, \
+ var, \
+ #ref, \
+ ref); \
+ return 1; \
+ }
-#define assert_leq(var, ref) \
- if (var > ref) { \
- fprintf(stderr, \
- "Assert fail in %s:%d\n", __FILE__, __LINE__); \
- fprintf(stderr, \
+#define assert_leq(var, ref) \
+ if(var > ref) \
+ { \
+ fprintf(stderr, \
+ "Assert fail in %s:%d\n", \
+ __FILE__, \
+ __LINE__); \
+ fprintf(stderr, \
"Value \"%s\" is not lower or equal to \"%s\":\n" \
- "%s == %d, %s == %d\n", \
- #var, #ref, #var, var, #ref, ref); \
- return 1; \
- }
+ "%s == %d, %s == %d\n", \
+ #var, \
+ #ref, \
+ #var, \
+ var, \
+ #ref, \
+ ref); \
+ return 1; \
+ }
#endif // ASSERT_H
#define SIGNAL_HELPER
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 TestButton
{
public:
-
- TestButton( unsigned int id )
+ TestButton(unsigned int id)
: mId(id)
{
}
void Press()
{
- mPanelDown.Emit( *this );
+ mPanelDown.Emit(*this);
}
void Release()
{
- mPanelUp.Emit( *this );
+ mPanelUp.Emit(*this);
}
- typedef Signal< void (TestButton&) > PanelDownSignal;
- typedef Signal< void (TestButton&) > PanelUpSignal;
+ typedef Signal<void(TestButton&)> PanelDownSignal;
+ typedef Signal<void(TestButton&)> PanelUpSignal;
PanelDownSignal& DownSignal()
{
}
private:
-
- int mId;
+ int mId;
PanelDownSignal mPanelDown;
PanelUpSignal mPanelUp;
};
class TestApp : public ConnectionTracker
{
public:
-
TestApp()
- : mButtonPressed( false ),
- mVoidFunctionCalled( false )
+ : mButtonPressed(false),
+ mVoidFunctionCalled(false)
{
}
- void OnButtonPress( TestButton& button )
+ void OnButtonPress(TestButton& button)
{
mButtonPressed = true;
- mButtonId = button.GetId();
+ mButtonId = button.GetId();
}
- void OnButtonRelease( TestButton& button )
+ void OnButtonRelease(TestButton& button)
{
mButtonPressed = false;
- mButtonId = button.GetId();
+ mButtonId = button.GetId();
}
int GetButtonPressedId()
bool mButtonPressed;
bool mVoidFunctionCalled;
- int mButtonId;
+ int mButtonId;
};
class TestSignals
{
public:
-
// Void return, no parameters
- typedef Signal<void ()> VoidRetNoParamSignal;
+ typedef Signal<void()> VoidRetNoParamSignal;
// Void return, 1 value parameter
- typedef Signal<void (int)> VoidRet1ValueParamSignal;
+ typedef Signal<void(int)> VoidRet1ValueParamSignal;
// Void return, 1 reference parameter
- typedef Signal< void (int&)> VoidRet1RefParamSignal;
+ typedef Signal<void(int&)> VoidRet1RefParamSignal;
// Void return, 2 value parameters
- typedef Signal<void (int, int)> VoidRet2ValueParamSignal;
+ typedef Signal<void(int, int)> VoidRet2ValueParamSignal;
// Void return, 3 value parameters
- typedef Signal<void (int, int, int)> VoidRet3ValueParamSignal;
+ typedef Signal<void(int, int, int)> VoidRet3ValueParamSignal;
// bool return, 1 value parameter
- typedef Signal< bool (float)> BoolRet1ValueParamSignal;
+ typedef Signal<bool(float)> BoolRet1ValueParamSignal;
// bool return, 2 value parameter
- typedef Signal<bool (float, int) > BoolRet2ValueParamSignal;
+ typedef Signal<bool(float, int)> BoolRet2ValueParamSignal;
// int return, 2 value parameter
- typedef Signal<int (float, int)> IntRet2ValueParamSignal;
+ typedef Signal<int(float, int)> IntRet2ValueParamSignal;
// float return, 0 parameters
- typedef Signal< float () > FloatRet0ParamSignal;
+ typedef Signal<float()> FloatRet0ParamSignal;
// float return, 1 value parameters
- typedef Signal< float (float ) > FloatRet1ParamSignal;
+ typedef Signal<float(float)> FloatRet1ParamSignal;
// float return, 2 value parameters
- typedef Signal<float (float, float) > FloatRet2ValueParamSignal;
+ typedef Signal<float(float, float)> FloatRet2ValueParamSignal;
// float return, 3 value parameters
- typedef Signal<float (float, float, float) > FloatRet3ValueParamSignal;
+ typedef Signal<float(float, float, float)> FloatRet3ValueParamSignal;
// void return, 3 value parameters
- typedef Signal<void (float, float, float) > VoidSignalTypeFloatValue3;
-
+ typedef Signal<void(float, float, float)> VoidSignalTypeFloatValue3;
- VoidRetNoParamSignal& SignalVoidNone() { return mSignalVoid0; }
- VoidRet1RefParamSignal& SignalVoid1Ref() { return mSignalVoid1R; }
- VoidRet1ValueParamSignal& SignalVoid1Value() { return mSignalVoid1V; }
- VoidRet2ValueParamSignal& SignalVoid2Value() { return mSignalVoid2V; }
- VoidRet3ValueParamSignal& SignalVoid3Value() { return mSignalVoid3V; }
+ VoidRetNoParamSignal& SignalVoidNone()
+ {
+ return mSignalVoid0;
+ }
+ VoidRet1RefParamSignal& SignalVoid1Ref()
+ {
+ return mSignalVoid1R;
+ }
+ VoidRet1ValueParamSignal& SignalVoid1Value()
+ {
+ return mSignalVoid1V;
+ }
+ VoidRet2ValueParamSignal& SignalVoid2Value()
+ {
+ return mSignalVoid2V;
+ }
+ VoidRet3ValueParamSignal& SignalVoid3Value()
+ {
+ return mSignalVoid3V;
+ }
- BoolRet1ValueParamSignal& SignalBool1Value() { return mSignalBool1V; }
- BoolRet2ValueParamSignal& SignalBool2Value() { return mSignalBool2V; }
- IntRet2ValueParamSignal& SignalInt2Value() { return mSignalInt2V; }
- FloatRet0ParamSignal& SignalFloat0() { return mSignalFloat0; }
- FloatRet1ParamSignal& SignalFloat1Value() {return mSignalFloat1V; }
- FloatRet2ValueParamSignal& SignalFloat2Value() { return mSignalFloat2V; }
+ BoolRet1ValueParamSignal& SignalBool1Value()
+ {
+ return mSignalBool1V;
+ }
+ BoolRet2ValueParamSignal& SignalBool2Value()
+ {
+ return mSignalBool2V;
+ }
+ IntRet2ValueParamSignal& SignalInt2Value()
+ {
+ return mSignalInt2V;
+ }
+ FloatRet0ParamSignal& SignalFloat0()
+ {
+ return mSignalFloat0;
+ }
+ FloatRet1ParamSignal& SignalFloat1Value()
+ {
+ return mSignalFloat1V;
+ }
+ FloatRet2ValueParamSignal& SignalFloat2Value()
+ {
+ return mSignalFloat2V;
+ }
- VoidSignalTypeFloatValue3& VoidSignalFloatValue3() { return mVoidSignalFloatValue3; }
- FloatRet3ValueParamSignal& SignalFloat3Value() { return mFloatSignalFloatValue3; }
+ VoidSignalTypeFloatValue3& VoidSignalFloatValue3()
+ {
+ return mVoidSignalFloatValue3;
+ }
+ FloatRet3ValueParamSignal& SignalFloat3Value()
+ {
+ return mFloatSignalFloatValue3;
+ }
TestSignals()
{
void CheckNoConnections()
{
- DALI_TEST_EQUALS( mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalVoid3V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalFloat1V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(mSignalVoid0.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalVoid1R.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalVoid1V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalVoid2V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalVoid3V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalBool1V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalBool2V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalInt2V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalFloat0.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalFloat1V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mSignalFloat2V.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mVoidSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mFloatSignalFloatValue3.GetConnectionCount(), 0u, TEST_LOCATION);
}
void EmitVoidSignalVoid()
void EmitVoidSignal2IntValue(int p1, int p2)
{
- mSignalVoid2V.Emit(p1,p2);
+ mSignalVoid2V.Emit(p1, p2);
}
void EmitVoidSignal3IntValue(int p1, int p2, int p3)
{
- mSignalVoid3V.Emit(p1,p2,p3);
+ mSignalVoid3V.Emit(p1, p2, p3);
}
-
bool EmitBoolSignalFloatValue(float p1)
{
return mSignalBool1V.Emit(p1);
return mSignalInt2V.Emit(p1, p2);
}
- float EmitFloat1VSignal(float p1 )
+ float EmitFloat1VSignal(float p1)
{
- return mSignalFloat1V.Emit(p1 );
+ return mSignalFloat1V.Emit(p1);
}
float EmitFloat2VSignal(float p1, float p2)
}
private:
-
- VoidRetNoParamSignal mSignalVoid0;
- VoidRet1RefParamSignal mSignalVoid1R;
- VoidRet1ValueParamSignal mSignalVoid1V;
- VoidRet2ValueParamSignal mSignalVoid2V;
- VoidRet3ValueParamSignal mSignalVoid3V;
-
- BoolRet1ValueParamSignal mSignalBool1V;
- BoolRet2ValueParamSignal mSignalBool2V;
- IntRet2ValueParamSignal mSignalInt2V;
- FloatRet0ParamSignal mSignalFloat0;
- FloatRet1ParamSignal mSignalFloat1V;
- FloatRet2ValueParamSignal mSignalFloat2V;
- VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
- FloatRet3ValueParamSignal mFloatSignalFloatValue3;
+ VoidRetNoParamSignal mSignalVoid0;
+ VoidRet1RefParamSignal mSignalVoid1R;
+ VoidRet1ValueParamSignal mSignalVoid1V;
+ VoidRet2ValueParamSignal mSignalVoid2V;
+ VoidRet3ValueParamSignal mSignalVoid3V;
+
+ BoolRet1ValueParamSignal mSignalBool1V;
+ BoolRet2ValueParamSignal mSignalBool2V;
+ IntRet2ValueParamSignal mSignalInt2V;
+ FloatRet0ParamSignal mSignalFloat0;
+ FloatRet1ParamSignal mSignalFloat1V;
+ FloatRet2ValueParamSignal mSignalFloat2V;
+ VoidSignalTypeFloatValue3 mVoidSignalFloatValue3;
+ FloatRet3ValueParamSignal mFloatSignalFloatValue3;
};
/**
class TestSlotHandler : public ConnectionTracker
{
public:
-
TestSlotHandler()
- : mIntParam1( 0 ),
- mIntParam2( 0 ),
- mIntParam3( 0 ),
- mFloatParam1( 0.0f ),
- mFloatParam2( 0.0f ),
- mFloatParam3( 0.0f ),
- mBoolReturn( false ),
- mIntReturn( 0 ),
- mFloatReturn( 0.0f ),
- mHandled( false ),
- mHandledCount( 0 )
+ : mIntParam1(0),
+ mIntParam2(0),
+ mIntParam3(0),
+ mFloatParam1(0.0f),
+ mFloatParam2(0.0f),
+ mFloatParam3(0.0f),
+ mBoolReturn(false),
+ mIntReturn(0),
+ mFloatReturn(0.0f),
+ mHandled(false),
+ mHandledCount(0)
{
}
void Reset()
{
- mIntParam1 = 0;
- mIntParam2 = 0;
- mIntParam3 = 0;
+ mIntParam1 = 0;
+ mIntParam2 = 0;
+ mIntParam3 = 0;
mFloatParam1 = 0.0f;
mFloatParam2 = 0.0f;
mFloatParam3 = 0.0f;
- mBoolReturn = false;
- mIntReturn = 0;
+ mBoolReturn = false;
+ mIntReturn = 0;
mFloatReturn = 0.0f;
- mHandled = false;
+ mHandled = false;
}
void VoidSlotVoid()
void VoidSlotVoidAlternative()
{
- mHandled = true;
- ++mHandledCount;
+ mHandled = true;
+ ++mHandledCount;
}
- void VoidSlotIntRef( int& p1 )
+ void VoidSlotIntRef(int& p1)
{
mIntParam1 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- void VoidSlotIntValue( int p1 )
+ void VoidSlotIntValue(int p1)
{
mIntParam1 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- void VoidDuplicateSlotIntValue( int p1 )
+ void VoidDuplicateSlotIntValue(int p1)
{
mIntParam2 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- void VoidSlotIntValueIntValue( int p1, int p2 )
+ void VoidSlotIntValueIntValue(int p1, int p2)
{
mIntParam1 = p1;
mIntParam2 = p2;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- bool BoolSlotFloatValue( float p1 )
+ bool BoolSlotFloatValue(float p1)
{
mFloatParam1 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
return mBoolReturn;
}
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ bool BoolSlotFloatValueIntValue(float p1, int p2)
{
mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
+ mIntParam2 = p2;
+ mHandled = true;
++mHandledCount;
return mBoolReturn;
}
- int IntSlotFloatValueIntValue( float p1, int p2 )
+ int IntSlotFloatValueIntValue(float p1, int p2)
{
mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
+ mIntParam2 = p2;
+ mHandled = true;
++mHandledCount;
return mIntReturn;
}
return mFloatReturn;
}
- float FloatSlotFloatValueFloatValue( float p1, float p2 )
+ float FloatSlotFloatValueFloatValue(float p1, float p2)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
return mFloatReturn;
}
- void VoidSlotFloatValue3( float p1, float p2, float p3 )
+ void VoidSlotFloatValue3(float p1, float p2, float p3)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
mFloatParam3 = p3;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- float FloatSlotFloatValue3( float p1, float p2, float p3 )
+ float FloatSlotFloatValue3(float p1, float p2, float p3)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
mFloatParam3 = p3;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
return mFloatReturn;
}
- int mIntParam1, mIntParam2, mIntParam3;
+ int mIntParam1, mIntParam2, mIntParam3;
float mFloatParam1, mFloatParam2, mFloatParam3;
- bool mBoolReturn;
- int mIntReturn;
+ bool mBoolReturn;
+ int mIntReturn;
float mFloatReturn;
- bool mHandled;
- int mHandledCount;
+ bool mHandled;
+ int mHandledCount;
};
/**
class TestSlotDisconnector : public ConnectionTracker
{
public:
-
TestSlotDisconnector()
- : mIntParam1( 0 ),
- mIntParam2( 0 ),
- mIntParam3( 0 ),
- mFloatParam1( 0.0f ),
- mFloatParam2( 0.0f ),
- mBoolReturn( false ),
- mIntReturn( 0 ),
- mFloatReturn( 0.0f ),
- mHandled( false )
+ : mIntParam1(0),
+ mIntParam2(0),
+ mIntParam3(0),
+ mFloatParam1(0.0f),
+ mFloatParam2(0.0f),
+ mBoolReturn(false),
+ mIntReturn(0),
+ mFloatReturn(0.0f),
+ mHandled(false)
{
}
void Reset()
{
- mIntParam1 = 0;
- mIntParam2 = 0;
- mIntParam3 = 0;
+ mIntParam1 = 0;
+ mIntParam2 = 0;
+ mIntParam3 = 0;
mFloatParam1 = 0.0f;
mFloatParam2 = 0.0f;
- mBoolReturn = false;
- mIntReturn = 0;
+ mBoolReturn = false;
+ mIntReturn = 0;
mFloatReturn = 0.0f;
- mHandled = false;
+ mHandled = false;
}
- void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
+ void VoidConnectVoid(TestSignals::VoidRetNoParamSignal& signal)
{
mVoidSignalVoid = &signal;
- signal.Connect( this, &TestSlotDisconnector::VoidSlotVoid );
+ signal.Connect(this, &TestSlotDisconnector::VoidSlotVoid);
}
void VoidSlotVoid()
{
- mVoidSignalVoid->Disconnect( this, &TestSlotDisconnector::VoidSlotVoid );
+ mVoidSignalVoid->Disconnect(this, &TestSlotDisconnector::VoidSlotVoid);
mHandled = true;
}
- void VoidConnectIntRef( TestSignals::VoidRet1RefParamSignal& signal )
+ void VoidConnectIntRef(TestSignals::VoidRet1RefParamSignal& signal)
{
mVoidSignalIntRef = &signal;
- signal.Connect( this, &TestSlotDisconnector::VoidSlotIntRef );
+ signal.Connect(this, &TestSlotDisconnector::VoidSlotIntRef);
}
- void VoidSlotIntRef( int& p1 )
+ void VoidSlotIntRef(int& p1)
{
- mVoidSignalIntRef->Disconnect( this, &TestSlotDisconnector::VoidSlotIntRef );
+ mVoidSignalIntRef->Disconnect(this, &TestSlotDisconnector::VoidSlotIntRef);
mIntParam1 = p1;
- mHandled = true;
+ mHandled = true;
}
- void VoidSlotIntValue( int p1 )
+ void VoidSlotIntValue(int p1)
{
mIntParam1 = p1;
- mHandled = true;
+ mHandled = true;
}
- void VoidSlotIntValueIntValue( int p1, int p2 )
+ void VoidSlotIntValueIntValue(int p1, int p2)
{
mIntParam1 = p1;
mIntParam2 = p2;
- mHandled = true;
+ mHandled = true;
}
- bool BoolSlotFloatValue( float p1 )
+ bool BoolSlotFloatValue(float p1)
{
mFloatParam1 = p1;
- mHandled = true;
+ mHandled = true;
return mBoolReturn;
}
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ bool BoolSlotFloatValueIntValue(float p1, int p2)
{
mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
+ mIntParam2 = p2;
+ mHandled = true;
return mBoolReturn;
}
- int IntSlotFloatValueIntValue( float p1, int p2 )
+ int IntSlotFloatValueIntValue(float p1, int p2)
{
mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
+ mIntParam2 = p2;
+ mHandled = true;
return mIntReturn;
}
return mFloatReturn;
}
- float FloatSlotFloatValueFloatValue( float p1, float p2 )
+ float FloatSlotFloatValueFloatValue(float p1, float p2)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
- mHandled = true;
+ mHandled = true;
return mFloatReturn;
}
TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
TestSignals::VoidRet1RefParamSignal* mVoidSignalIntRef;
- int mIntParam1, mIntParam2, mIntParam3;
+ int mIntParam1, mIntParam2, mIntParam3;
float mFloatParam1, mFloatParam2;
- bool mBoolReturn;
- int mIntReturn;
+ bool mBoolReturn;
+ int mIntReturn;
float mFloatReturn;
- bool mHandled;
+ bool mHandled;
};
/**
class TestSlotMultiDisconnector : public ConnectionTracker
{
public:
-
static const int NUM_SLOTS = 10;
TestSlotMultiDisconnector()
- : mVoidSignalVoid( NULL )
+ : mVoidSignalVoid(NULL)
{
Reset();
}
void Reset()
{
- for( int i=0; i<NUM_SLOTS; ++i )
+ for(int i = 0; i < NUM_SLOTS; ++i)
{
mSlotHandled[i] = false;
}
}
- void ConnectAll( TestSignals::VoidRetNoParamSignal& signal )
+ void ConnectAll(TestSignals::VoidRetNoParamSignal& signal)
{
mVoidSignalVoid = &signal;
- signal.Connect( this, &TestSlotMultiDisconnector::Slot0 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot1 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot2 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot3 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot4 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot5 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot6 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot7 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot8 );
- signal.Connect( this, &TestSlotMultiDisconnector::Slot9 );
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot0);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot1);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot2);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot3);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot4);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot5);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot6);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot7);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot8);
+ signal.Connect(this, &TestSlotMultiDisconnector::Slot9);
}
void Slot0()
mSlotHandled[3] = true;
// Disconnect the odd numbered lots, because we can
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot1 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot3 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot5 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot7 );
- mVoidSignalVoid->Disconnect( this, &TestSlotMultiDisconnector::Slot9 );
+ mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot1);
+ mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot3);
+ mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot5);
+ mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot7);
+ mVoidSignalVoid->Disconnect(this, &TestSlotMultiDisconnector::Slot9);
}
void Slot4()
bool mSlotHandled[NUM_SLOTS];
};
-
/**
* A version of TestSlotHandler which disconnects during the callback
*/
class TestEmitDuringCallback : public ConnectionTracker
{
public:
-
TestEmitDuringCallback()
- : mVoidSignalVoid( NULL ),
- mFloatRet0ParamSignal( NULL),
- mFloatRet1ParamSignal( NULL ),
- mFloatRet2ParamSignal( NULL ),
- mFloatRet3ParamSignal( NULL ),
- mHandled( false )
+ : mVoidSignalVoid(NULL),
+ mFloatRet0ParamSignal(NULL),
+ mFloatRet1ParamSignal(NULL),
+ mFloatRet2ParamSignal(NULL),
+ mFloatRet3ParamSignal(NULL),
+ mHandled(false)
{
}
- void VoidConnectVoid( TestSignals::VoidRetNoParamSignal& signal )
+ void VoidConnectVoid(TestSignals::VoidRetNoParamSignal& signal)
{
mVoidSignalVoid = &signal;
- signal.Connect( this, &TestEmitDuringCallback::VoidSlotVoid );
+ signal.Connect(this, &TestEmitDuringCallback::VoidSlotVoid);
}
- void FloatRet0ParamConnect( TestSignals::FloatRet0ParamSignal& signal )
+ void FloatRet0ParamConnect(TestSignals::FloatRet0ParamSignal& signal)
{
mFloatRet0ParamSignal = &signal;
- signal.Connect( this, &TestEmitDuringCallback::FloatRet0Param );
+ signal.Connect(this, &TestEmitDuringCallback::FloatRet0Param);
}
- void FloatRet1ParamConnect( TestSignals::FloatRet1ParamSignal& signal )
+ void FloatRet1ParamConnect(TestSignals::FloatRet1ParamSignal& signal)
{
mFloatRet1ParamSignal = &signal;
- signal.Connect( this, &TestEmitDuringCallback::FloatRet1Param );
+ signal.Connect(this, &TestEmitDuringCallback::FloatRet1Param);
}
- void FloatRet2ParamConnect( TestSignals::FloatRet2ValueParamSignal& signal )
+ void FloatRet2ParamConnect(TestSignals::FloatRet2ValueParamSignal& signal)
{
mFloatRet2ParamSignal = &signal;
- signal.Connect( this, &TestEmitDuringCallback::FloatRet2Param );
+ signal.Connect(this, &TestEmitDuringCallback::FloatRet2Param);
}
- void FloatRet3ParamConnect( TestSignals::FloatRet3ValueParamSignal& signal )
+ void FloatRet3ParamConnect(TestSignals::FloatRet3ValueParamSignal& signal)
{
mFloatRet3ParamSignal = &signal;
- signal.Connect( this, &TestEmitDuringCallback::FloatRet3Param );
+ signal.Connect(this, &TestEmitDuringCallback::FloatRet3Param);
}
- void DeleteDuringEmitConnect( TestSignals::VoidRetNoParamSignal& signal )
+ void DeleteDuringEmitConnect(TestSignals::VoidRetNoParamSignal& signal)
{
mVoidSignalVoid = &signal;
- signal.Connect( this, &TestEmitDuringCallback::DeleteSignalDuringEmit );
+ signal.Connect(this, &TestEmitDuringCallback::DeleteSignalDuringEmit);
}
void VoidSlotVoid()
float FloatRet0Param()
{
- // Emitting during Emit is very bad!
+ // Emitting during Emit is very bad!
mHandled = true;
return mFloatRet0ParamSignal->Emit();
}
- float FloatRet1Param( float x )
+ float FloatRet1Param(float x)
{
// Emitting during Emit is very bad!
mHandled = true;
return mFloatRet1ParamSignal->Emit(x);
}
- float FloatRet2Param( float x, float y )
+ float FloatRet2Param(float x, float y)
{
// Emitting during Emit is very bad!
mHandled = true;
- return mFloatRet2ParamSignal->Emit( x, y );
+ return mFloatRet2ParamSignal->Emit(x, y);
}
- float FloatRet3Param( float x, float y, float z)
+ float FloatRet3Param(float x, float y, float z)
{
// Emitting during Emit is very bad!
mHandled = true;
- return mFloatRet3ParamSignal->Emit( x, y, z );
+ return mFloatRet3ParamSignal->Emit(x, y, z);
}
- TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
+ TestSignals::VoidRetNoParamSignal* mVoidSignalVoid;
TestSignals::FloatRet0ParamSignal* mFloatRet0ParamSignal;
- TestSignals::FloatRet1ParamSignal* mFloatRet1ParamSignal;
+ TestSignals::FloatRet1ParamSignal* mFloatRet1ParamSignal;
TestSignals::FloatRet2ValueParamSignal* mFloatRet2ParamSignal;
TestSignals::FloatRet3ValueParamSignal* mFloatRet3ParamSignal;
-
bool mHandled;
};
-
/**
* A version of TestSlotHandler which uses SlotDelegate
*/
class TestSlotDelegateHandler // This does not inherit from ConnectionTrackerInterface!
{
public:
-
TestSlotDelegateHandler()
- : mSlotDelegate( this ),
- mIntParam1( 0 ),
- mIntParam2( 0 ),
- mIntParam3( 0 ),
- mFloatParam1( 0.0f ),
- mFloatParam2( 0.0f ),
- mFloatParam3( 0.0f ),
- mBoolReturn( false ),
- mIntReturn( 0 ),
- mFloatReturn( 0.0f ),
- mHandled( false ),
- mHandledCount( 0 )
+ : mSlotDelegate(this),
+ mIntParam1(0),
+ mIntParam2(0),
+ mIntParam3(0),
+ mFloatParam1(0.0f),
+ mFloatParam2(0.0f),
+ mFloatParam3(0.0f),
+ mBoolReturn(false),
+ mIntReturn(0),
+ mFloatReturn(0.0f),
+ mHandled(false),
+ mHandledCount(0)
{
}
void Reset()
{
- mIntParam1 = 0;
- mIntParam2 = 0;
- mIntParam3 = 0;
+ mIntParam1 = 0;
+ mIntParam2 = 0;
+ mIntParam3 = 0;
mFloatParam1 = 0.0f;
mFloatParam2 = 0.0f;
mFloatParam3 = 0.0f;
- mBoolReturn = false;
- mIntReturn = 0;
+ mBoolReturn = false;
+ mIntReturn = 0;
mFloatReturn = 0.0f;
- mHandled = false;
+ mHandled = false;
}
void VoidSlotVoid()
++mHandledCount;
}
- void VoidSlotIntRef( int& p1 )
+ void VoidSlotIntRef(int& p1)
{
mIntParam1 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- void VoidSlotIntValue( int p1 )
+ void VoidSlotIntValue(int p1)
{
mIntParam1 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- void VoidDuplicateSlotIntValue( int p1 )
+ void VoidDuplicateSlotIntValue(int p1)
{
mIntParam2 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- void VoidSlotIntValueIntValue( int p1, int p2 )
+ void VoidSlotIntValueIntValue(int p1, int p2)
{
mIntParam1 = p1;
mIntParam2 = p2;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- bool BoolSlotFloatValue( float p1 )
+ bool BoolSlotFloatValue(float p1)
{
mFloatParam1 = p1;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
return mBoolReturn;
}
- bool BoolSlotFloatValueIntValue( float p1, int p2 )
+ bool BoolSlotFloatValueIntValue(float p1, int p2)
{
mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
+ mIntParam2 = p2;
+ mHandled = true;
++mHandledCount;
return mBoolReturn;
}
- int IntSlotFloatValueIntValue( float p1, int p2 )
+ int IntSlotFloatValueIntValue(float p1, int p2)
{
mFloatParam1 = p1;
- mIntParam2 = p2;
- mHandled = true;
+ mIntParam2 = p2;
+ mHandled = true;
++mHandledCount;
return mIntReturn;
}
return mFloatReturn;
}
- float FloatSlotFloatValueFloatValue( float p1, float p2 )
+ float FloatSlotFloatValueFloatValue(float p1, float p2)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
return mFloatReturn;
}
- void VoidSlotFloatValue3( float p1, float p2, float p3 )
+ void VoidSlotFloatValue3(float p1, float p2, float p3)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
mFloatParam3 = p3;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
}
- float FloatSlotFloatValue3( float p1, float p2, float p3 )
+ float FloatSlotFloatValue3(float p1, float p2, float p3)
{
mFloatParam1 = p1;
mFloatParam2 = p2;
mFloatParam3 = p3;
- mHandled = true;
+ mHandled = true;
++mHandledCount;
return mFloatReturn;
}
SlotDelegate<TestSlotDelegateHandler> mSlotDelegate;
- int mIntParam1, mIntParam2, mIntParam3;
+ int mIntParam1, mIntParam2, mIntParam3;
float mFloatParam1, mFloatParam2, mFloatParam3;
- bool mBoolReturn;
- int mIntReturn;
+ bool mBoolReturn;
+ int mIntReturn;
float mFloatReturn;
- bool mHandled;
- int mHandledCount;
+ bool mHandled;
+ int mHandledCount;
};
/**
class TestBasicConnectionTrackerInterface : public ConnectionTrackerInterface
{
public:
-
TestBasicConnectionTrackerInterface()
- : mCallbackHandled( false ),
- mCallback( NULL ),
- mSlotObserver( NULL )
+ : mCallbackHandled(false),
+ mCallback(NULL),
+ mSlotObserver(NULL)
{
}
~TestBasicConnectionTrackerInterface()
{
- if( mSlotObserver && mCallback )
+ if(mSlotObserver && mCallback)
{
// Notify signal since the slot has been destroyed
- mSlotObserver->SlotDisconnected( mCallback );
+ mSlotObserver->SlotDisconnected(mCallback);
// mCallback and mSlotObserver are not owned
}
}
*/
virtual std::size_t GetConnectionCount() const
{
- if( mCallback )
+ if(mCallback)
{
return 1u;
}
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
+ virtual void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- DALI_ASSERT_ALWAYS( NULL == mCallback && "Only one connection supported!" );
+ DALI_ASSERT_ALWAYS(NULL == mCallback && "Only one connection supported!");
- mCallback = callback;
+ mCallback = callback;
mSlotObserver = slotObserver;
}
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback )
+ virtual void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- if( mSlotObserver == slotObserver )
+ if(mSlotObserver == slotObserver)
{
mSlotObserver = NULL;
- mCallback = NULL;
+ mCallback = NULL;
// mCallback and mSlotObserver are not owned
}
}
*/
void RemoveNullCallback()
{
- mSlotObserver->SlotDisconnected( NULL );
+ mSlotObserver->SlotDisconnected(NULL);
}
private:
-
- TestBasicConnectionTrackerInterface( const TestBasicConnectionTrackerInterface& ); ///< undefined copy constructor
- TestBasicConnectionTrackerInterface& operator=( const TestBasicConnectionTrackerInterface& ); ///< undefined assignment operator
+ TestBasicConnectionTrackerInterface(const TestBasicConnectionTrackerInterface&); ///< undefined copy constructor
+ TestBasicConnectionTrackerInterface& operator=(const TestBasicConnectionTrackerInterface&); ///< undefined assignment operator
public:
-
bool mCallbackHandled;
private:
-
CallbackBase* mCallback; ///< callback, has ownership
SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
};
-
-
-
// for testing static function callbacks
class StaticFunctionHandlers
{
public:
- StaticFunctionHandlers()
- {
- staticFunctionHandled = false;
- }
- void Reset()
- {
- staticFunctionHandled = false;
- }
+ StaticFunctionHandlers()
+ {
+ staticFunctionHandled = false;
+ }
+ void Reset()
+ {
+ staticFunctionHandled = false;
+ }
- static void VoidSlotVoid()
- {
- staticFunctionHandled = true;
- }
- static void VoidSlot1Param( int p1 )
- {
- staticFunctionHandled = true;
- }
- static void VoidSlot2Param( int p1, int p2 )
- {
- staticFunctionHandled = true;
- }
- static void VoidSlot3Param( int p1, int p2, int p3 )
- {
- staticFunctionHandled = true;
- }
+ static void VoidSlotVoid()
+ {
+ staticFunctionHandled = true;
+ }
+ static void VoidSlot1Param(int p1)
+ {
+ staticFunctionHandled = true;
+ }
+ static void VoidSlot2Param(int p1, int p2)
+ {
+ staticFunctionHandled = true;
+ }
+ static void VoidSlot3Param(int p1, int p2, int p3)
+ {
+ staticFunctionHandled = true;
+ }
- static float RetSlot0Param( )
- {
- staticFunctionHandled = true;
- return 0;
- }
- static float RetSlot1Param( float p1 )
- {
- staticFunctionHandled = true;
- return 0;
- }
- static float RetSlot2Param( float p1, float p2 )
- {
- staticFunctionHandled = true;
- return 0;
- }
- static float RetSlot3Param( float p1, float p2, float p3 )
- {
- staticFunctionHandled = true;
- return 0;
- }
+ static float RetSlot0Param()
+ {
+ staticFunctionHandled = true;
+ return 0;
+ }
+ static float RetSlot1Param(float p1)
+ {
+ staticFunctionHandled = true;
+ return 0;
+ }
+ static float RetSlot2Param(float p1, float p2)
+ {
+ staticFunctionHandled = true;
+ return 0;
+ }
+ static float RetSlot3Param(float p1, float p2, float p3)
+ {
+ staticFunctionHandled = true;
+ return 0;
+ }
- static bool staticFunctionHandled;
+ static bool staticFunctionHandled;
};
-
/**
* test functor, we store a reference to a bool which is outside of the functor
* so when the functor is copied, the copy can reference the original data
*/
struct TestFunctor
{
- TestFunctor( bool& functorCalled):
- mFunctorCalled( functorCalled )
- {
- };
+ TestFunctor(bool& functorCalled)
+ : mFunctorCalled(functorCalled){};
void operator()()
{
struct VoidFunctorVoid
{
- VoidFunctorVoid( bool& functorCalled):
- mFunctorCalled( functorCalled )
+ VoidFunctorVoid(bool& functorCalled)
+ : mFunctorCalled(functorCalled)
{
-
}
void operator()()
typedef int (*tc_fun_ptr)(void);
/* struct describing specific testcase */
-typedef struct testcase_s {
- const char* name;
- tc_fun_ptr function;
- void_fun_ptr startup;
- void_fun_ptr cleanup;
+typedef struct testcase_s
+{
+ const char* name;
+ tc_fun_ptr function;
+ void_fun_ptr startup;
+ void_fun_ptr cleanup;
} testcase;
#endif // TESTCASE_H
-#include <string.h>
#include <getopt.h>
#include <stdlib.h>
+#include <string.h>
#include <test-harness.h>
+
#include "tct-dali-internal-core.h"
-int main(int argc, char * const argv[])
+int main(int argc, char* const argv[])
{
int result = TestHarness::EXIT_STATUS_BAD_ARGUMENT;
const char* optString = "sf";
- bool optRerunFailed(true);
- bool optRunSerially(false);
+ bool optRerunFailed(true);
+ bool optRunSerially(false);
int nextOpt = 0;
do
{
- nextOpt = getopt( argc, argv, optString );
+ nextOpt = getopt(argc, argv, optString);
switch(nextOpt)
{
case 'f':
exit(TestHarness::EXIT_STATUS_BAD_ARGUMENT);
break;
}
- } while( nextOpt != -1 );
+ } while(nextOpt != -1);
- if( optind == argc ) // no testcase name in argument list
+ if(optind == argc) // no testcase name in argument list
{
- if( optRunSerially )
+ if(optRunSerially)
{
- result = TestHarness::RunAll( argv[0], tc_array );
+ result = TestHarness::RunAll(argv[0], tc_array);
}
else
{
- result = TestHarness::RunAllInParallel( argv[0], tc_array, optRerunFailed );
+ result = TestHarness::RunAllInParallel(argv[0], tc_array, optRerunFailed);
}
}
else
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-
#include <dali-test-suite-utils.h>
#include <dali/public-api/signals/callback.h>
+#include <stdlib.h>
+
+#include <iostream>
// Internal headers are allowed here
#include <dali/internal/event/actors/actor-impl.h>
namespace TestCallback
{
Internal::Actor* disconnectedActor = nullptr;
-int callCount = 0;
-void Function( Internal::Actor* actor )
+int callCount = 0;
+void Function(Internal::Actor* actor)
{
disconnectedActor = actor;
++callCount;
void Reset()
{
- callCount = 0;
+ callCount = 0;
disconnectedActor = nullptr;
}
{
TestApplication application;
- auto scene = application.GetScene();
- auto actor = Actor::New();
- auto& actorImpl = GetImplementation( actor );
+ auto scene = application.GetScene();
+ auto actor = Actor::New();
+ auto& actorImpl = GetImplementation(actor);
// Ensure we're not observing anything at the start
ActorObserver actorObserver;
- DALI_TEST_EQUALS( actorObserver.GetActor(), nullptr, TEST_LOCATION );
+ DALI_TEST_EQUALS(actorObserver.GetActor(), nullptr, TEST_LOCATION);
// Set the actor and ensure GetActor returns the correct pointer
- actorObserver.SetActor( &actorImpl );
- DALI_TEST_EQUALS( actorObserver.GetActor(), &actorImpl, TEST_LOCATION );
+ actorObserver.SetActor(&actorImpl);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), &actorImpl, TEST_LOCATION);
- scene.Add( actor );
- DALI_TEST_EQUALS( actorObserver.GetActor(), &actorImpl, TEST_LOCATION );
+ scene.Add(actor);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), &actorImpl, TEST_LOCATION);
// Removing the actor from the scene should make it return null
- scene.Remove( actor );
- DALI_TEST_EQUALS( actorObserver.GetActor(), nullptr, TEST_LOCATION );
+ scene.Remove(actor);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), nullptr, TEST_LOCATION);
// Adding the actor back to the scene should mean it returning the actor again
- scene.Add( actor );
- DALI_TEST_EQUALS( actorObserver.GetActor(), &actorImpl, TEST_LOCATION );
+ scene.Add(actor);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), &actorImpl, TEST_LOCATION);
// Resetting the actor should return nullptr
actorObserver.ResetActor();
- DALI_TEST_EQUALS( actorObserver.GetActor(), nullptr, TEST_LOCATION );
+ DALI_TEST_EQUALS(actorObserver.GetActor(), nullptr, TEST_LOCATION);
// Set the actor again
- actorObserver.SetActor( &actorImpl );
- DALI_TEST_EQUALS( actorObserver.GetActor(), &actorImpl, TEST_LOCATION );
+ actorObserver.SetActor(&actorImpl);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), &actorImpl, TEST_LOCATION);
// Create another Actor and observe that (don't add it to the scene just yet)
{
- auto actor2 = Actor::New();
- auto& actor2Impl = GetImplementation( actor2 );
- actorObserver.SetActor( &actor2Impl );
- DALI_TEST_EQUALS( actorObserver.GetActor(), &actor2Impl, TEST_LOCATION );
+ auto actor2 = Actor::New();
+ auto& actor2Impl = GetImplementation(actor2);
+ actorObserver.SetActor(&actor2Impl);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), &actor2Impl, TEST_LOCATION);
}
// Actor destroyed now, should return nullptr
- DALI_TEST_EQUALS( actorObserver.GetActor(), nullptr, TEST_LOCATION );
+ DALI_TEST_EQUALS(actorObserver.GetActor(), nullptr, TEST_LOCATION);
END_TEST;
}
{
{
// Scope lifetime of Actor
- auto actor = Actor::New();
- auto& actorImpl = GetImplementation( actor );
+ auto actor = Actor::New();
+ auto& actorImpl = GetImplementation(actor);
// Now scope the lifetime of ActorObserver
{
ActorObserver actorObserver;
- actorObserver.SetActor( &actorImpl );
+ actorObserver.SetActor(&actorImpl);
} // ActorObserver goes out of scope
- } // Actor goes out of scope
+ } // Actor goes out of scope
// If we get here without a crash, then it's all good
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
- catch( ... )
+ catch(...)
{
- tet_infoline( "ActorObserver did not clean up properly" );
- DALI_TEST_CHECK( false );
+ tet_infoline("ActorObserver did not clean up properly");
+ DALI_TEST_CHECK(false);
}
END_TEST;
// Copy empty observer
ActorObserver observer1;
- ActorObserver observer2( std::move( observer1 ) );
- DALI_TEST_EQUALS( observer1.GetActor(), nullptr, TEST_LOCATION );
- DALI_TEST_EQUALS( observer2.GetActor(), nullptr, TEST_LOCATION );
+ ActorObserver observer2(std::move(observer1));
+ DALI_TEST_EQUALS(observer1.GetActor(), nullptr, TEST_LOCATION);
+ DALI_TEST_EQUALS(observer2.GetActor(), nullptr, TEST_LOCATION);
// Assign empty observer
- observer1 = std::move( observer2 );
- DALI_TEST_EQUALS( observer1.GetActor(), nullptr, TEST_LOCATION );
- DALI_TEST_EQUALS( observer2.GetActor(), nullptr, TEST_LOCATION );
+ observer1 = std::move(observer2);
+ DALI_TEST_EQUALS(observer1.GetActor(), nullptr, TEST_LOCATION);
+ DALI_TEST_EQUALS(observer2.GetActor(), nullptr, TEST_LOCATION);
// Ensure self assignment doesn't change anything
- observer1 = std::move( observer1 );
- observer2 = std::move( observer2 );
- DALI_TEST_EQUALS( observer1.GetActor(), nullptr, TEST_LOCATION );
- DALI_TEST_EQUALS( observer2.GetActor(), nullptr, TEST_LOCATION );
+ observer1 = std::move(observer1);
+ observer2 = std::move(observer2);
+ DALI_TEST_EQUALS(observer1.GetActor(), nullptr, TEST_LOCATION);
+ DALI_TEST_EQUALS(observer2.GetActor(), nullptr, TEST_LOCATION);
END_TEST;
}
// Ensure new observer is observing the correct actor
// Ensure previous observer is not observing anything any more
- auto actor = Actor::New();
- auto& actorImpl = GetImplementation( actor );
+ auto actor = Actor::New();
+ auto& actorImpl = GetImplementation(actor);
ActorObserver observer1;
- observer1.SetActor( &actorImpl );
- DALI_TEST_EQUALS( observer1.GetActor(), &actorImpl, TEST_LOCATION );
+ observer1.SetActor(&actorImpl);
+ DALI_TEST_EQUALS(observer1.GetActor(), &actorImpl, TEST_LOCATION);
// Move constructor
- ActorObserver observer2( std::move( observer1 ) );
- DALI_TEST_EQUALS( observer1.GetActor(), nullptr, TEST_LOCATION );
- DALI_TEST_EQUALS( observer2.GetActor(), &actorImpl, TEST_LOCATION );
+ ActorObserver observer2(std::move(observer1));
+ DALI_TEST_EQUALS(observer1.GetActor(), nullptr, TEST_LOCATION);
+ DALI_TEST_EQUALS(observer2.GetActor(), &actorImpl, TEST_LOCATION);
// Move assignment
- observer1 = std::move( observer2 );
- DALI_TEST_EQUALS( observer1.GetActor(), &actorImpl, TEST_LOCATION );
- DALI_TEST_EQUALS( observer2.GetActor(), nullptr, TEST_LOCATION );
+ observer1 = std::move(observer2);
+ DALI_TEST_EQUALS(observer1.GetActor(), &actorImpl, TEST_LOCATION);
+ DALI_TEST_EQUALS(observer2.GetActor(), nullptr, TEST_LOCATION);
// Self assignment
- observer1 = std::move( observer1 );
- observer2 = std::move( observer2 );
- DALI_TEST_EQUALS( observer1.GetActor(), &actorImpl, TEST_LOCATION );
- DALI_TEST_EQUALS( observer2.GetActor(), nullptr, TEST_LOCATION );
+ observer1 = std::move(observer1);
+ observer2 = std::move(observer2);
+ DALI_TEST_EQUALS(observer1.GetActor(), &actorImpl, TEST_LOCATION);
+ DALI_TEST_EQUALS(observer2.GetActor(), nullptr, TEST_LOCATION);
END_TEST;
}
{
{
// Scope lifetime of Actor
- auto actor = Actor::New();
- auto& actorImpl = GetImplementation( actor );
+ auto actor = Actor::New();
+ auto& actorImpl = GetImplementation(actor);
// Score lifetime of observers
{
ActorObserver observer1;
- observer1.SetActor( &actorImpl );
- ActorObserver observer2( std::move( observer1 ) );
+ observer1.SetActor(&actorImpl);
+ ActorObserver observer2(std::move(observer1));
} // Both observers die here
- } // Actor goes out of scope
+ } // Actor goes out of scope
// If we get here without a crash, then it's all good
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
- catch( ... )
+ catch(...)
{
- tet_infoline( "ActorObserver did not clean up properly" );
- DALI_TEST_CHECK( false );
+ tet_infoline("ActorObserver did not clean up properly");
+ DALI_TEST_CHECK(false);
}
END_TEST;
// Test to ensure the passed in callback is called when the observed actor is disconnected
TestCallback::Reset();
- auto scene = application.GetScene();
- auto actor = Actor::New();
- auto& actorImpl = GetImplementation( actor );
- scene.Add( actor );
+ auto scene = application.GetScene();
+ auto actor = Actor::New();
+ auto& actorImpl = GetImplementation(actor);
+ scene.Add(actor);
- ActorObserver actorObserver( MakeCallback( &TestCallback::Function ) );
- actorObserver.SetActor( &actorImpl );
- DALI_TEST_EQUALS( actorObserver.GetActor(), &actorImpl, TEST_LOCATION );
- DALI_TEST_EQUALS( TestCallback::disconnectedActor, nullptr, TEST_LOCATION );
+ ActorObserver actorObserver(MakeCallback(&TestCallback::Function));
+ actorObserver.SetActor(&actorImpl);
+ DALI_TEST_EQUALS(actorObserver.GetActor(), &actorImpl, TEST_LOCATION);
+ DALI_TEST_EQUALS(TestCallback::disconnectedActor, nullptr, TEST_LOCATION);
// Remove Actor from scene
actor.Unparent();
- DALI_TEST_EQUALS( actorObserver.GetActor(), nullptr, TEST_LOCATION );
- DALI_TEST_EQUALS( TestCallback::disconnectedActor, &actorImpl, TEST_LOCATION );
+ DALI_TEST_EQUALS(actorObserver.GetActor(), nullptr, TEST_LOCATION);
+ DALI_TEST_EQUALS(TestCallback::disconnectedActor, &actorImpl, TEST_LOCATION);
END_TEST;
}
try
{
- auto scene = application.GetScene();
- auto actor = Actor::New();
- auto& actorImpl = GetImplementation( actor );
- scene.Add( actor );
+ auto scene = application.GetScene();
+ auto actor = Actor::New();
+ auto& actorImpl = GetImplementation(actor);
+ scene.Add(actor);
- ActorObserver *observer1 = new ActorObserver( MakeCallback( &TestCallback::Function ) );
- observer1->SetActor( &actorImpl );
+ ActorObserver* observer1 = new ActorObserver(MakeCallback(&TestCallback::Function));
+ observer1->SetActor(&actorImpl);
// Move observer1 into a new observer
- ActorObserver* observer2 = new ActorObserver( std::move( *observer1 ) );
+ ActorObserver* observer2 = new ActorObserver(std::move(*observer1));
// Remove actor from scene, function should be called only once
actor.Unparent();
- DALI_TEST_EQUALS( TestCallback::disconnectedActor, &actorImpl, TEST_LOCATION );
- DALI_TEST_EQUALS( TestCallback::callCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(TestCallback::disconnectedActor, &actorImpl, TEST_LOCATION);
+ DALI_TEST_EQUALS(TestCallback::callCount, 1, TEST_LOCATION);
// Delete both observers here, only one of them should delete the callback
delete observer1;
delete observer2;
// If we get here without a crash, then the callback has NOT been double-freed
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( false );
- tet_infoline( "Callback double Freed" );
+ DALI_TEST_CHECK(false);
+ tet_infoline("Callback double Freed");
}
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
+#include <dali-test-suite-utils.h>
#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
// Internal headers are allowed here
-
using namespace Dali;
void utc_dali_internal_core_startup()
namespace
{
-
class RelayoutSignalHandler : public Dali::ConnectionTracker
{
public:
-
- RelayoutSignalHandler( TestApplication& application )
- : mApplication( application ),
- mSignalCalled( false )
+ RelayoutSignalHandler(TestApplication& application)
+ : mApplication(application),
+ mSignalCalled(false)
{
}
// callback to be connected to RelayoutSignal
- void RelayoutCallback( Actor actor )
+ void RelayoutCallback(Actor actor)
{
tet_infoline("RelayoutCallback is called");
}
TestApplication& mApplication;
- bool mSignalCalled;
+ bool mSignalCalled;
};
} // anonymous namespace
TestApplication application;
tet_infoline("Testing Dali::Integration::Core::ProcessEvents");
- Vector3 size( 100.0f, 100.0f, 0.0f );
- Vector3 position( 100.0f, 100.0f, 0.0f );
+ Vector3 size(100.0f, 100.0f, 0.0f);
+ Vector3 position(100.0f, 100.0f, 0.0f);
Actor actor = Actor::New();
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- actor.SetProperty( Actor::Property::SIZE, size );
- actor.SetProperty( Actor::Property::POSITION, position );
- application.GetScene().Add( actor );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ actor.SetProperty(Actor::Property::SIZE, size);
+ actor.SetProperty(Actor::Property::POSITION, position);
+ application.GetScene().Add(actor);
- RelayoutSignalHandler relayoutSignal( application );
- actor.OnRelayoutSignal().Connect( &relayoutSignal, &RelayoutSignalHandler::RelayoutCallback );
+ RelayoutSignalHandler relayoutSignal(application);
+ actor.OnRelayoutSignal().Connect(&relayoutSignal, &RelayoutSignalHandler::RelayoutCallback);
application.SendNotification();
- DALI_TEST_EQUALS( relayoutSignal.mSignalCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(relayoutSignal.mSignalCalled, true, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >(), size, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::POSITION ).Get< Vector3 >(), position, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE).Get<Vector3>(), size, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), position, TEST_LOCATION);
END_TEST;
}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
// Internal headers are allowed here
namespace
{
-
unsigned int gTestObjectConstructed = 0;
-unsigned int gTestObjectDestructed = 0;
-unsigned int gTestObjectMethod = 0;
-unsigned int gTestObjectDataAccess = 0;
+unsigned int gTestObjectDestructed = 0;
+unsigned int gTestObjectMethod = 0;
+unsigned int gTestObjectDataAccess = 0;
} // namespace
-
class TestObject
{
public:
-
TestObject()
- : mData1( 0 ),
- mData2( false )
+ : mData1(0),
+ mData2(false)
{
gTestObjectConstructed++;
}
}
private:
-
unsigned int mData1;
- bool mData2;
-
+ bool mData2;
};
int UtcDaliFixedSizeMemoryPoolCreate(void)
{
gTestObjectConstructed = 0;
- gTestObjectDestructed = 0;
- gTestObjectMethod = 0;
- gTestObjectDataAccess = 0;
+ gTestObjectDestructed = 0;
+ gTestObjectMethod = 0;
+ gTestObjectDataAccess = 0;
- Internal::FixedSizeMemoryPool memoryPool( Internal::TypeSizeWithAlignment< TestObject >::size );
+ Internal::FixedSizeMemoryPool memoryPool(Internal::TypeSizeWithAlignment<TestObject>::size);
- TestObject* testObject1 = new (memoryPool.Allocate()) TestObject();
- DALI_TEST_CHECK( testObject1 );
- DALI_TEST_EQUALS( gTestObjectConstructed, 1U, TEST_LOCATION );
+ TestObject* testObject1 = new(memoryPool.Allocate()) TestObject();
+ DALI_TEST_CHECK(testObject1);
+ DALI_TEST_EQUALS(gTestObjectConstructed, 1U, TEST_LOCATION);
testObject1->Method();
- DALI_TEST_EQUALS( gTestObjectMethod, 1U, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTestObjectMethod, 1U, TEST_LOCATION);
testObject1->DataAccess();
- DALI_TEST_EQUALS( gTestObjectDataAccess, 1U, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTestObjectDataAccess, 1U, TEST_LOCATION);
testObject1->~TestObject();
- memoryPool.Free( testObject1 );
- DALI_TEST_EQUALS( gTestObjectDestructed, 1U, TEST_LOCATION );
+ memoryPool.Free(testObject1);
+ DALI_TEST_EQUALS(gTestObjectDestructed, 1U, TEST_LOCATION);
END_TEST;
}
int UtcDaliFixedSizeMemoryPoolStressTest(void)
{
gTestObjectConstructed = 0;
- gTestObjectDestructed = 0;
- gTestObjectMethod = 0;
- gTestObjectDataAccess = 0;
+ gTestObjectDestructed = 0;
+ gTestObjectMethod = 0;
+ gTestObjectDataAccess = 0;
const size_t initialCapacity = 32;
const size_t maximumCapacity = 1024;
const unsigned int numObjects = 1024 * 1024;
- Internal::FixedSizeMemoryPool memoryPool( Internal::TypeSizeWithAlignment< TestObject >::size, initialCapacity, maximumCapacity );
+ Internal::FixedSizeMemoryPool memoryPool(Internal::TypeSizeWithAlignment<TestObject>::size, initialCapacity, maximumCapacity);
Dali::Vector<TestObject*> objects;
- objects.Reserve( numObjects );
+ objects.Reserve(numObjects);
- for( unsigned int i = 0; i < numObjects; ++i )
+ for(unsigned int i = 0; i < numObjects; ++i)
{
- TestObject* testObject = new ( memoryPool.Allocate() ) TestObject();
- DALI_TEST_CHECK( testObject );
+ TestObject* testObject = new(memoryPool.Allocate()) TestObject();
+ DALI_TEST_CHECK(testObject);
- objects.PushBack( testObject );
+ objects.PushBack(testObject);
}
- DALI_TEST_EQUALS( gTestObjectConstructed, numObjects, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTestObjectConstructed, numObjects, TEST_LOCATION);
- for( unsigned int i = 0; i < numObjects; ++i )
+ for(unsigned int i = 0; i < numObjects; ++i)
{
objects[i]->~TestObject();
- memoryPool.Free( objects[i] );
+ memoryPool.Free(objects[i]);
}
- DALI_TEST_EQUALS( gTestObjectDestructed, numObjects, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTestObjectDestructed, numObjects, TEST_LOCATION);
END_TEST;
}
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/dali-core.h>
#include <dali/integration-api/bitmap.h>
-#include <iostream>
-#include <algorithm>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
+#include <algorithm>
+#include <iostream>
+
// INTERNAL INCLUDES
#include <dali-test-suite-utils.h>
#include <mesh-builder.h>
using namespace Dali;
-#define MAKE_SHADER(A)#A
+#define MAKE_SHADER(A) #A
const char* VERTEX_SHADER = MAKE_SHADER(
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-varying mediump vec2 vTexCoord;
-
-void main()
-{
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
- vertexPosition.xyz *= uSize;
- vertexPosition = uMvpMatrix * vertexPosition;
- vTexCoord = aTexCoord;
- gl_Position = vertexPosition;
-}
-);
+ attribute mediump vec2 aPosition;
+ attribute mediump vec2 aTexCoord;
+ uniform mediump mat4 uMvpMatrix;
+ uniform mediump vec3 uSize;
+ varying mediump vec2 vTexCoord;
+
+ void main() {
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ vertexPosition.xyz *= uSize;
+ vertexPosition = uMvpMatrix * vertexPosition;
+ vTexCoord = aTexCoord;
+ gl_Position = vertexPosition;
+ });
const char* FRAGMENT_SHADER = MAKE_SHADER(
-uniform Sampler2D sTexture;
-varying mediump vec2 vTexCoord;
-void main()
-{
- gl_FragColor = texture2D( sTexture, vTexCoord );
-}
-);
+ uniform Sampler2D sTexture;
+ varying mediump vec2 vTexCoord;
+ void main() {
+ gl_FragColor = texture2D(sTexture, vTexCoord);
+ });
-Actor CreateMeshActorToScene( TestApplication& application, Vector3 parentOrigin = ParentOrigin::CENTER, Vector3 anchorPoint = AnchorPoint::CENTER, Shader::Hint::Value shaderHints = Shader::Hint::NONE )
+Actor CreateMeshActorToScene(TestApplication& application, Vector3 parentOrigin = ParentOrigin::CENTER, Vector3 anchorPoint = AnchorPoint::CENTER, Shader::Hint::Value shaderHints = Shader::Hint::NONE)
{
- Integration::PixelBuffer* pixelBuffer = new Integration::PixelBuffer[ 4 ];
- PixelData pixelData = PixelData::New(pixelBuffer, 4, 1, 1, Pixel::RGBA8888, PixelData::DELETE_ARRAY);
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Integration::PixelBuffer* pixelBuffer = new Integration::PixelBuffer[4];
+ PixelData pixelData = PixelData::New(pixelBuffer, 4, 1, 1, Pixel::RGBA8888, PixelData::DELETE_ARRAY);
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
image.Upload(pixelData);
- Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, shaderHints );
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = Shader::New(VERTEX_SHADER, FRAGMENT_SHADER, shaderHints);
TextureSet textureSet = TextureSet::New();
textureSet.SetTexture(0u, image);
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor meshActor = Actor::New();
- meshActor.AddRenderer( renderer );
- meshActor.SetProperty( Actor::Property::SIZE, Vector3( 400.0f, 400.0f, 0.1f ) );
- meshActor.SetProperty( Actor::Property::PARENT_ORIGIN, parentOrigin );
- meshActor.SetProperty( Actor::Property::ANCHOR_POINT, anchorPoint );
- application.GetScene().Add( meshActor );
+ meshActor.AddRenderer(renderer);
+ meshActor.SetProperty(Actor::Property::SIZE, Vector3(400.0f, 400.0f, 0.1f));
+ meshActor.SetProperty(Actor::Property::PARENT_ORIGIN, parentOrigin);
+ meshActor.SetProperty(Actor::Property::ANCHOR_POINT, anchorPoint);
+ application.GetScene().Add(meshActor);
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
return meshActor;
}
-bool GetCameraDepths( TestApplication& application, float& nearPlane, float& farPlane, float& cameraDepth )
+bool GetCameraDepths(TestApplication& application, float& nearPlane, float& farPlane, float& cameraDepth)
{
RenderTaskList renderTasks = application.GetScene().GetRenderTaskList();
- CameraActor cameraActor;
- for( unsigned int i = 0; i < renderTasks.GetTaskCount(); ++i )
+ CameraActor cameraActor;
+ for(unsigned int i = 0; i < renderTasks.GetTaskCount(); ++i)
{
- RenderTask task = renderTasks.GetTask( i );
- cameraActor = task.GetCameraActor();
- if( cameraActor )
+ RenderTask task = renderTasks.GetTask(i);
+ cameraActor = task.GetCameraActor();
+ if(cameraActor)
{
break;
}
}
- if( cameraActor )
+ if(cameraActor)
{
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- nearPlane = cameraActor.GetNearClippingPlane();
- farPlane = cameraActor.GetFarClippingPlane();
- cameraDepth = cameraActor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z;
+ nearPlane = cameraActor.GetNearClippingPlane();
+ farPlane = cameraActor.GetFarClippingPlane();
+ cameraDepth = cameraActor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z;
}
return !!cameraActor;
int UtcFrustumCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- CreateMeshActorToScene( application );
+ CreateMeshActorToScene(application);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumLeftCullP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = -0.01f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( offset, 0.5f, 0.5f ), AnchorPoint::CENTER_RIGHT );
+ float offset = -0.01f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(offset, 0.5f, 0.5f), AnchorPoint::CENTER_RIGHT);
- float radius = meshActor.GetTargetSize().Length() * 0.5f;
+ float radius = meshActor.GetTargetSize().Length() * 0.5f;
Vector2 sceneSize = application.GetScene().GetSize();
- meshActor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( -radius / sceneSize.width + offset, 0.5f, 0.5f ) );
- meshActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ meshActor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(-radius / sceneSize.width + offset, 0.5f, 0.5f));
+ meshActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be sphere culled
- DALI_TEST_CHECK( !drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumLeftCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = 0.01f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( offset, 0.5f, 0.5f ), AnchorPoint::CENTER_RIGHT );
+ float offset = 0.01f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(offset, 0.5f, 0.5f), AnchorPoint::CENTER_RIGHT);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumRightCullP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = 1.01f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( offset, 0.5f, 0.5f ), AnchorPoint::CENTER_LEFT );
+ float offset = 1.01f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(offset, 0.5f, 0.5f), AnchorPoint::CENTER_LEFT);
- float radius = meshActor.GetTargetSize().Length() * 0.5f;
+ float radius = meshActor.GetTargetSize().Length() * 0.5f;
Vector2 sceneSize = application.GetScene().GetSize();
- meshActor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( radius / sceneSize.width + offset, 0.5f, 0.5f ) );
- meshActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ meshActor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(radius / sceneSize.width + offset, 0.5f, 0.5f));
+ meshActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be sphere culled
- DALI_TEST_CHECK( !drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumRightCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = 0.99f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( offset, 0.5f, 0.5f ), AnchorPoint::CENTER_LEFT );
+ float offset = 0.99f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(offset, 0.5f, 0.5f), AnchorPoint::CENTER_LEFT);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumTopCullP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = -0.01f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( 0.5f, offset, 0.5f ), AnchorPoint::BOTTOM_CENTER );
+ float offset = -0.01f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(0.5f, offset, 0.5f), AnchorPoint::BOTTOM_CENTER);
- float radius = meshActor.GetTargetSize().Length() * 0.5f;
+ float radius = meshActor.GetTargetSize().Length() * 0.5f;
Vector2 sceneSize = application.GetScene().GetSize();
- meshActor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.5f, -radius / sceneSize.width + offset, 0.5f ) );
- meshActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ meshActor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, -radius / sceneSize.width + offset, 0.5f));
+ meshActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be sphere culled
- DALI_TEST_CHECK( !drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumTopCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = 0.01f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( 0.5f, offset, 0.5f ), AnchorPoint::BOTTOM_CENTER );
+ float offset = 0.01f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(0.5f, offset, 0.5f), AnchorPoint::BOTTOM_CENTER);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be box culled
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumBottomCullP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = 1.01f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( 0.5f, offset, 0.5f ), AnchorPoint::TOP_CENTER );
+ float offset = 1.01f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(0.5f, offset, 0.5f), AnchorPoint::TOP_CENTER);
- float radius = meshActor.GetTargetSize().Length() * 0.5f;
+ float radius = meshActor.GetTargetSize().Length() * 0.5f;
Vector2 sceneSize = application.GetScene().GetSize();
- meshActor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.5f, radius / sceneSize.width + offset, 0.5f ) );
- meshActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ meshActor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5f, radius / sceneSize.width + offset, 0.5f));
+ meshActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be sphere culled
- DALI_TEST_CHECK( !drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumBottomCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- float offset = 0.99f;
- Actor meshActor = CreateMeshActorToScene( application, Vector3( 0.5f, offset, 0.5f ), AnchorPoint::TOP_CENTER );
+ float offset = 0.99f;
+ Actor meshActor = CreateMeshActorToScene(application, Vector3(0.5f, offset, 0.5f), AnchorPoint::TOP_CENTER);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumNearCullP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
float nearPlane, farPlane, cameraDepth;
- DALI_TEST_CHECK( GetCameraDepths( application, nearPlane, farPlane, cameraDepth ) );
+ DALI_TEST_CHECK(GetCameraDepths(application, nearPlane, farPlane, cameraDepth));
- Actor meshActor = CreateMeshActorToScene( application );
- Vector3 meshPosition = meshActor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
+ Actor meshActor = CreateMeshActorToScene(application);
+ Vector3 meshPosition = meshActor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
- float radius = meshActor.GetTargetSize().Length() * 0.5f;
- float offset = radius + 0.1f;
+ float radius = meshActor.GetTargetSize().Length() * 0.5f;
+ float offset = radius + 0.1f;
meshPosition.z = cameraDepth - nearPlane + offset;
- meshActor.SetProperty( Actor::Property::POSITION, meshPosition );
+ meshActor.SetProperty(Actor::Property::POSITION, meshPosition);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be sphere culled
- DALI_TEST_CHECK( !drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumNearCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
float nearPlane, farPlane, cameraDepth;
- DALI_TEST_CHECK( GetCameraDepths( application, nearPlane, farPlane, cameraDepth ) );
+ DALI_TEST_CHECK(GetCameraDepths(application, nearPlane, farPlane, cameraDepth));
- Actor meshActor = CreateMeshActorToScene( application );
- Vector3 meshPosition = meshActor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
+ Actor meshActor = CreateMeshActorToScene(application);
+ Vector3 meshPosition = meshActor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
- float offset = meshActor.GetTargetSize().z - 0.1f;
+ float offset = meshActor.GetTargetSize().z - 0.1f;
meshPosition.z = cameraDepth - nearPlane + offset;
- meshActor.SetProperty( Actor::Property::POSITION, meshPosition );
+ meshActor.SetProperty(Actor::Property::POSITION, meshPosition);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumFarCullP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
float nearPlane, farPlane, cameraDepth;
- DALI_TEST_CHECK( GetCameraDepths( application, nearPlane, farPlane, cameraDepth ) );
+ DALI_TEST_CHECK(GetCameraDepths(application, nearPlane, farPlane, cameraDepth));
- Actor meshActor = CreateMeshActorToScene( application );
- Vector3 meshPosition = meshActor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
+ Actor meshActor = CreateMeshActorToScene(application);
+ Vector3 meshPosition = meshActor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
- float radius = meshActor.GetTargetSize().Length() * 0.5f;
- float offset = radius + 0.1f;
+ float radius = meshActor.GetTargetSize().Length() * 0.5f;
+ float offset = radius + 0.1f;
meshPosition.z = cameraDepth - farPlane - offset;
- meshActor.SetProperty( Actor::Property::POSITION, meshPosition );
+ meshActor.SetProperty(Actor::Property::POSITION, meshPosition);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This will be sphere culled
- DALI_TEST_CHECK( !drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumFarCullN(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
float nearPlane, farPlane, cameraDepth;
- DALI_TEST_CHECK( GetCameraDepths( application, nearPlane, farPlane, cameraDepth ) );
+ DALI_TEST_CHECK(GetCameraDepths(application, nearPlane, farPlane, cameraDepth));
- Actor meshActor = CreateMeshActorToScene( application );
- Vector3 meshPosition = meshActor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
+ Actor meshActor = CreateMeshActorToScene(application);
+ Vector3 meshPosition = meshActor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
- float offset = meshActor.GetTargetSize().z - 0.1f;
+ float offset = meshActor.GetTargetSize().z - 0.1f;
meshPosition.z = cameraDepth - farPlane - offset;
- meshActor.SetProperty( Actor::Property::POSITION, meshPosition );
+ meshActor.SetProperty(Actor::Property::POSITION, meshPosition);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
int UtcFrustumCullDisabledP(void)
{
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
- drawTrace.Enable( true );
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ drawTrace.Enable(true);
- CreateMeshActorToScene( application, Vector3( 7.0f, 0.5f, 0.5f ), AnchorPoint::CENTER, Shader::Hint::MODIFIES_GEOMETRY );
+ CreateMeshActorToScene(application, Vector3(7.0f, 0.5f, 0.5f), AnchorPoint::CENTER, Shader::Hint::MODIFIES_GEOMETRY);
drawTrace.Reset();
application.SendNotification();
- application.Render( 16 );
+ application.Render(16);
// This should not be culled
- DALI_TEST_CHECK( drawTrace.FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(drawTrace.FindMethod("DrawElements"));
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
#include <dali/internal/event/events/gesture-impl.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
// TestGesture Struct (Gesture constructor is protected)
struct TestGesture : public Internal::Gesture
{
public:
TestGesture(GestureType::Value type, GestureState state)
- : Gesture(type, state) {}
+ : Gesture(type, state)
+ {
+ }
- virtual ~TestGesture() {}
+ virtual ~TestGesture()
+ {
+ }
};
-} // anon namespace
+} // namespace
int UtcDaliGestureConstructorP(void)
{
TestApplication application; // Reset all test adapter return codes
Gesture empty;
- DALI_TEST_CHECK( !empty );
+ DALI_TEST_CHECK(!empty);
- Gesture pan( new TestGesture(GestureType::PAN, GestureState::STARTED) );
+ Gesture pan(new TestGesture(GestureType::PAN, GestureState::STARTED));
DALI_TEST_EQUALS(GestureType::PAN, pan.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, pan.GetState(), TEST_LOCATION);
- Gesture pinch( new TestGesture(GestureType::PINCH, GestureState::CLEAR) );
+ Gesture pinch(new TestGesture(GestureType::PINCH, GestureState::CLEAR));
DALI_TEST_EQUALS(GestureType::PINCH, pinch.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CLEAR, pinch.GetState(), TEST_LOCATION);
// Test move constructor
const auto refCount = pan.GetObjectPtr()->ReferenceCount();
- Gesture pan3( std::move( pan ) );
+ Gesture pan3(std::move(pan));
DALI_TEST_EQUALS(pan, Gesture(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, pan3.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(pan3.GetBaseObject().ReferenceCount(), refCount, TEST_LOCATION);
TestApplication application; // Reset all test adapter return codes
// Test Assignment operator
- Gesture pan( new TestGesture(GestureType::PAN, GestureState::FINISHED) );
+ Gesture pan(new TestGesture(GestureType::PAN, GestureState::FINISHED));
DALI_TEST_EQUALS(GestureType::PAN, pan.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, pan.GetState(), TEST_LOCATION);
- Gesture test( new TestGesture(GestureType::PINCH, GestureState::STARTED) );
+ Gesture test(new TestGesture(GestureType::PINCH, GestureState::STARTED));
DALI_TEST_EQUALS(GestureType::PINCH, test.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, test.GetState(), TEST_LOCATION);
// Move assignment
const auto refCount = pan.GetObjectPtr()->ReferenceCount();
- Gesture pan3;
+ Gesture pan3;
DALI_TEST_EQUALS(pan3, Gesture(), TEST_LOCATION);
pan3 = std::move(pan);
DALI_TEST_EQUALS(pan, Gesture(), TEST_LOCATION);
{
TestApplication application; // Reset all test adapter return codes
- Gesture pan( new TestGesture(GestureType::PAN, GestureState::STARTED) );
+ Gesture pan(new TestGesture(GestureType::PAN, GestureState::STARTED));
DALI_TEST_EQUALS(GestureType::PAN, pan.GetType(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Gesture pan( new TestGesture(GestureType::PAN, GestureState::STARTED) );
+ Gesture pan(new TestGesture(GestureType::PAN, GestureState::STARTED));
DALI_TEST_EQUALS(GestureState::STARTED, pan.GetState(), TEST_LOCATION);
GetImplementation(pan).SetState(GestureState::FINISHED);
{
TestApplication application; // Reset all test adapter return codes
- Gesture pan( new TestGesture(GestureType::PAN, GestureState::STARTED) );
+ Gesture pan(new TestGesture(GestureType::PAN, GestureState::STARTED));
DALI_TEST_EQUALS(0, pan.GetTime(), TEST_LOCATION);
GetImplementation(pan).SetTime(61282);
END_TEST;
}
-
*
*/
-#include <iostream>
-
-#include <stdlib.h>
+#include <dali-test-suite-utils.h>
#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
// Internal headers are allowed here
-
using namespace Dali;
void utc_dali_internal_handles_startup()
test_return_value = TET_PASS;
}
-
int UtcDaliCameraActorConstructorRefObject(void)
{
TestApplication application;
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/long-press-gesture-devel.h>
#include <dali/internal/event/events/long-press-gesture/long-press-gesture-impl.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
{
TestApplication application;
- LongPressGesture gesture(new Internal::LongPressGesture( GestureState::STARTED ));
+ LongPressGesture gesture = DevelLongPressGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::LONG_PRESS, gesture.GetType(), TEST_LOCATION);
// Test Copy constructor
- GetImplementation( gesture ).SetNumberOfTouches( 5u );
+ GetImplementation(gesture).SetNumberOfTouches(5u);
LongPressGesture gesture2(gesture);
DALI_TEST_EQUALS(5u, gesture2.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, gesture2.GetState(), TEST_LOCATION);
// Test move constructor
- const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
- LongPressGesture gesture3( std::move( gesture ) );
+ const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
+ LongPressGesture gesture3(std::move(gesture));
DALI_TEST_EQUALS(gesture, LongPressGesture(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::LONG_PRESS, gesture3.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(gesture3.GetBaseObject().ReferenceCount(), refCount, TEST_LOCATION);
int UtcDaliLongPressGestureAssignmentP(void)
{
// Test Assignment operator
- LongPressGesture gesture(new Internal::LongPressGesture( GestureState::STARTED ));
+ LongPressGesture gesture = DevelLongPressGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::LONG_PRESS, gesture.GetType(), TEST_LOCATION);
- GetImplementation( gesture ).SetNumberOfTouches( 5u );
+ GetImplementation(gesture).SetNumberOfTouches(5u);
- LongPressGesture gesture2(new Internal::LongPressGesture( GestureState::FINISHED ));
+ LongPressGesture gesture2 = DevelLongPressGesture::New(GestureState::FINISHED);
DALI_TEST_EQUALS(GestureState::FINISHED, gesture2.GetState(), TEST_LOCATION);
gesture2 = gesture;
DALI_TEST_EQUALS(5u, gesture2.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, gesture2.GetState(), TEST_LOCATION);
// Move assignment
- const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
+ const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
LongPressGesture gesture3;
DALI_TEST_EQUALS(gesture3, Gesture(), TEST_LOCATION);
gesture3 = std::move(gesture);
{
TestApplication application;
- LongPressGesture gesture(new Internal::LongPressGesture(GestureState::STARTED));
+ LongPressGesture gesture = DevelLongPressGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetNumberOfTouches(), 1, TEST_LOCATION);
GetImplementation(gesture).SetNumberOfTouches(4);
{
TestApplication application;
- LongPressGesture gesture(new Internal::LongPressGesture(GestureState::STARTED));
- DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO , TEST_LOCATION);
- DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO , TEST_LOCATION);
+ LongPressGesture gesture = DevelLongPressGesture::New(GestureState::STARTED);
+ DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO, TEST_LOCATION);
GetImplementation(gesture).SetScreenPoint(Vector2(100.0f, 300.0f));
DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2(100.0f, 300.0f), TEST_LOCATION);
- DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO , TEST_LOCATION);
+ DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- LongPressGesture gesture(new Internal::LongPressGesture(GestureState::STARTED));
- DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO , TEST_LOCATION);
- DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO , TEST_LOCATION);
+ LongPressGesture gesture = DevelLongPressGesture::New(GestureState::STARTED);
+ DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO, TEST_LOCATION);
GetImplementation(gesture).SetLocalPoint(Vector2(100.0f, 300.0f));
DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2(100.0f, 300.0f), TEST_LOCATION);
- DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO , TEST_LOCATION);
+ DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO, TEST_LOCATION);
END_TEST;
}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
// Internal headers are allowed here
int testObjectDataAccess;
MemoryPoolObjectAllocatorTestObjectTracking()
- : testObjectDestructed( 0 ),
- testObjectMethod( 0 ),
- testObjectDataAccess( 0 )
+ : testObjectDestructed(0),
+ testObjectMethod(0),
+ testObjectDataAccess(0)
{
}
};
class MemoryPoolObjectAllocatorTestObject
{
public:
-
MemoryPoolObjectAllocatorTestObject()
- : mData1( 0 ),
- mData2( false ),
- mTracking( NULL )
+ : mData1(0),
+ mData2(false),
+ mTracking(NULL)
{
}
~MemoryPoolObjectAllocatorTestObject()
{
- if( mTracking )
+ if(mTracking)
{
mTracking->testObjectDestructed++;
}
void Method()
{
- if( mTracking )
+ if(mTracking)
{
mTracking->testObjectMethod++;
}
mData1++;
mData2 = true;
- if( mTracking )
+ if(mTracking)
{
mTracking->testObjectDataAccess++;
}
}
- void SetTracking( MemoryPoolObjectAllocatorTestObjectTracking* tracking )
+ void SetTracking(MemoryPoolObjectAllocatorTestObjectTracking* tracking)
{
mTracking = tracking;
}
private:
-
- int mData1;
+ int mData1;
bool mData2;
MemoryPoolObjectAllocatorTestObjectTracking* mTracking;
int UtcDaliMemoryPoolObjectAllocatorObjectAllocation(void)
{
-
- Internal::MemoryPoolObjectAllocator< MemoryPoolObjectAllocatorTestObject > allocator;
+ Internal::MemoryPoolObjectAllocator<MemoryPoolObjectAllocatorTestObject> allocator;
// Allocate an object
MemoryPoolObjectAllocatorTestObject* testObject1 = allocator.Allocate();
- DALI_TEST_CHECK( testObject1 );
+ DALI_TEST_CHECK(testObject1);
MemoryPoolObjectAllocatorTestObjectTracking tracking1;
- testObject1->SetTracking( &tracking1 );
+ testObject1->SetTracking(&tracking1);
testObject1->Method();
- DALI_TEST_EQUALS( tracking1.testObjectMethod, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracking1.testObjectMethod, 1, TEST_LOCATION);
testObject1->DataAccess();
- DALI_TEST_EQUALS( tracking1.testObjectDataAccess, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracking1.testObjectDataAccess, 1, TEST_LOCATION);
- allocator.Destroy( testObject1 );
- DALI_TEST_EQUALS( tracking1.testObjectDestructed, 1, TEST_LOCATION );
+ allocator.Destroy(testObject1);
+ DALI_TEST_EQUALS(tracking1.testObjectDestructed, 1, TEST_LOCATION);
// Reset and allocate another object
allocator.ResetMemoryPool();
MemoryPoolObjectAllocatorTestObject* testObject2 = allocator.Allocate();
- DALI_TEST_CHECK( testObject2 );
+ DALI_TEST_CHECK(testObject2);
MemoryPoolObjectAllocatorTestObjectTracking tracking2;
- testObject2->SetTracking( &tracking2 );
+ testObject2->SetTracking(&tracking2);
testObject2->Method();
- DALI_TEST_EQUALS( tracking2.testObjectMethod, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracking2.testObjectMethod, 1, TEST_LOCATION);
testObject2->DataAccess();
- DALI_TEST_EQUALS( tracking2.testObjectDataAccess, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracking2.testObjectDataAccess, 1, TEST_LOCATION);
- allocator.Destroy( testObject2 );
- DALI_TEST_EQUALS( tracking2.testObjectDestructed, 1, TEST_LOCATION );
+ allocator.Destroy(testObject2);
+ DALI_TEST_EQUALS(tracking2.testObjectDestructed, 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliMemoryPoolObjectAllocatorObjectRawAllocation(void)
{
- Internal::MemoryPoolObjectAllocator< MemoryPoolObjectAllocatorTestObject > allocator;
+ Internal::MemoryPoolObjectAllocator<MemoryPoolObjectAllocatorTestObject> allocator;
- MemoryPoolObjectAllocatorTestObject* testObject = new ( allocator.AllocateRaw() ) MemoryPoolObjectAllocatorTestObject();
- DALI_TEST_CHECK( testObject );
+ MemoryPoolObjectAllocatorTestObject* testObject = new(allocator.AllocateRaw()) MemoryPoolObjectAllocatorTestObject();
+ DALI_TEST_CHECK(testObject);
MemoryPoolObjectAllocatorTestObjectTracking tracking;
- testObject->SetTracking( &tracking );
+ testObject->SetTracking(&tracking);
testObject->Method();
- DALI_TEST_EQUALS( tracking.testObjectMethod, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracking.testObjectMethod, 1, TEST_LOCATION);
testObject->DataAccess();
- DALI_TEST_EQUALS( tracking.testObjectDataAccess, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracking.testObjectDataAccess, 1, TEST_LOCATION);
- allocator.Destroy( testObject );
- DALI_TEST_EQUALS( tracking.testObjectDestructed, 1, TEST_LOCATION );
+ allocator.Destroy(testObject);
+ DALI_TEST_EQUALS(tracking.testObjectDestructed, 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliMemoryPoolObjectAllocatorObjectAllocationPOD(void)
{
- Internal::MemoryPoolObjectAllocator< bool > allocator;
+ Internal::MemoryPoolObjectAllocator<bool> allocator;
bool* testObject1 = allocator.Allocate();
- DALI_TEST_CHECK( testObject1 );
+ DALI_TEST_CHECK(testObject1);
- allocator.Destroy( testObject1 );
+ allocator.Destroy(testObject1);
allocator.ResetMemoryPool();
bool* testObject2 = allocator.Allocate();
- DALI_TEST_CHECK( testObject2 );
+ DALI_TEST_CHECK(testObject2);
- allocator.Destroy( testObject2 );
+ allocator.Destroy(testObject2);
END_TEST;
}
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
/// Takes in a reference to a bool which is set to true when the destructor is called
class OwnedClass
{
public:
-
- OwnedClass( bool& destructorCalled )
- : mDestructorCalled( destructorCalled )
+ OwnedClass(bool& destructorCalled)
+ : mDestructorCalled(destructorCalled)
{
mDestructorCalled = false;
}
}
private:
-
bool& mDestructorCalled;
};
functionCalled = true;
}
- bool functionCalled{ false };
+ bool functionCalled{false};
};
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
bool deleted = false;
{
- OwnerPointer< OwnedClass > pointer( new OwnedClass( deleted ) );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ OwnerPointer<OwnedClass> pointer(new OwnedClass(deleted));
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
}
// OwnerPointer out-of-scope, object should be deleted.
- DALI_TEST_EQUALS( deleted, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(deleted, true, TEST_LOCATION);
END_TEST;
}
{
// Ensure the default constructor is created as expected.
- OwnerPointer< OwnedClass > pointer;
- DALI_TEST_CHECK( pointer.Get() == nullptr );
+ OwnerPointer<OwnedClass> pointer;
+ DALI_TEST_CHECK(pointer.Get() == nullptr);
END_TEST;
}
{
// Call copy constructor and assignment operator
- bool deleted = false;
- OwnedClass* owned = new OwnedClass( deleted );
+ bool deleted = false;
+ OwnedClass* owned = new OwnedClass(deleted);
- OwnerPointer< OwnedClass > first( owned );
- DALI_TEST_CHECK( first.Get() == owned );
+ OwnerPointer<OwnedClass> first(owned);
+ DALI_TEST_CHECK(first.Get() == owned);
{
// Copy constructor, first should have a nullptr now, no object deletion
- OwnerPointer< OwnedClass > second( first );
- DALI_TEST_CHECK( first.Get() == nullptr );
- DALI_TEST_CHECK( second.Get() == owned);
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ OwnerPointer<OwnedClass> second(first);
+ DALI_TEST_CHECK(first.Get() == nullptr);
+ DALI_TEST_CHECK(second.Get() == owned);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
// Self assignment, nothing should change or be deleted.
- first = first;
+ first = first;
second = second;
- DALI_TEST_CHECK( first.Get() == nullptr );
- DALI_TEST_CHECK( second.Get() == owned );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ DALI_TEST_CHECK(first.Get() == nullptr);
+ DALI_TEST_CHECK(second.Get() == owned);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
// Assign second to first, no deletion, second should have a nullptr now
first = second;
- DALI_TEST_CHECK( first.Get() == owned );
- DALI_TEST_CHECK( second.Get() == nullptr );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ DALI_TEST_CHECK(first.Get() == owned);
+ DALI_TEST_CHECK(second.Get() == nullptr);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
}
// second is out-of-scope now, no object deletion
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
// Assign to an empty pointer, owned object should be deleted
- OwnerPointer< OwnedClass > empty;
+ OwnerPointer<OwnedClass> empty;
first = empty;
- DALI_TEST_EQUALS( deleted, true, TEST_LOCATION );
- DALI_TEST_CHECK( first.Get() == nullptr );
- DALI_TEST_CHECK( empty.Get() == nullptr );
+ DALI_TEST_EQUALS(deleted, true, TEST_LOCATION);
+ DALI_TEST_CHECK(first.Get() == nullptr);
+ DALI_TEST_CHECK(empty.Get() == nullptr);
END_TEST;
}
{
// Call move constructor and move assignment operator
- bool deleted = false;
- OwnedClass* owned = new OwnedClass( deleted );
+ bool deleted = false;
+ OwnedClass* owned = new OwnedClass(deleted);
- OwnerPointer< OwnedClass > first( owned );
- DALI_TEST_CHECK( first.Get() == owned );
+ OwnerPointer<OwnedClass> first(owned);
+ DALI_TEST_CHECK(first.Get() == owned);
{
// Move constructor, first should have a nullptr now, no object deletion
- OwnerPointer< OwnedClass > second( std::move( first ) );
- DALI_TEST_CHECK( first.Get() == nullptr );
- DALI_TEST_CHECK( second.Get() == owned);
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ OwnerPointer<OwnedClass> second(std::move(first));
+ DALI_TEST_CHECK(first.Get() == nullptr);
+ DALI_TEST_CHECK(second.Get() == owned);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
// Self assignment, nothing should change or be deleted.
- first = std::move( first );
- second = std::move( second );
- DALI_TEST_CHECK( first.Get() == nullptr );
- DALI_TEST_CHECK( second.Get() == owned );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ first = std::move(first);
+ second = std::move(second);
+ DALI_TEST_CHECK(first.Get() == nullptr);
+ DALI_TEST_CHECK(second.Get() == owned);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
// Assign second to first, no deletion, second should have a nullptr now
- first = std::move( second );
- DALI_TEST_CHECK( first.Get() == owned );
- DALI_TEST_CHECK( second.Get() == nullptr );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ first = std::move(second);
+ DALI_TEST_CHECK(first.Get() == owned);
+ DALI_TEST_CHECK(second.Get() == nullptr);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
}
// second is out-of-scope now, no object deletion
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
// Assign to an empty pointer, owned object should be deleted
- OwnerPointer< OwnedClass > empty;
- first = std::move( empty );
- DALI_TEST_EQUALS( deleted, true, TEST_LOCATION );
- DALI_TEST_CHECK( first.Get() == nullptr );
- DALI_TEST_CHECK( empty.Get() == nullptr );
+ OwnerPointer<OwnedClass> empty;
+ first = std::move(empty);
+ DALI_TEST_EQUALS(deleted, true, TEST_LOCATION);
+ DALI_TEST_CHECK(first.Get() == nullptr);
+ DALI_TEST_CHECK(empty.Get() == nullptr);
END_TEST;
}
{
// Check the indirection operators
- using Ptr = OwnerPointer< int >;
+ using Ptr = OwnerPointer<int>;
{
- int* rawIntPtr( new int( 200 ) );
- Ptr nonConstPtr( rawIntPtr );
- DALI_TEST_CHECK( rawIntPtr == &( *nonConstPtr ) );
- DALI_TEST_EQUALS( *nonConstPtr, 200, TEST_LOCATION );
+ int* rawIntPtr(new int(200));
+ Ptr nonConstPtr(rawIntPtr);
+ DALI_TEST_CHECK(rawIntPtr == &(*nonConstPtr));
+ DALI_TEST_EQUALS(*nonConstPtr, 200, TEST_LOCATION);
}
{
- int* rawIntPtr2( new int( 300 ) );
- const Ptr constPtr( rawIntPtr2 );
- DALI_TEST_CHECK( rawIntPtr2 == &( *constPtr ) );
- DALI_TEST_EQUALS( *constPtr, 300, TEST_LOCATION );
+ int* rawIntPtr2(new int(300));
+ const Ptr constPtr(rawIntPtr2);
+ DALI_TEST_CHECK(rawIntPtr2 == &(*constPtr));
+ DALI_TEST_EQUALS(*constPtr, 300, TEST_LOCATION);
}
END_TEST;
{
// Check the pointer operators
- using Ptr = OwnerPointer< ClassWithFunction >;
+ using Ptr = OwnerPointer<ClassWithFunction>;
// Check if function is called as expected when using a const OwnerPointer
{
- ClassWithFunction* rawPtr( new ClassWithFunction );
- Ptr nonConstPtr( rawPtr );
- DALI_TEST_EQUALS( rawPtr->functionCalled, false, TEST_LOCATION );
+ ClassWithFunction* rawPtr(new ClassWithFunction);
+ Ptr nonConstPtr(rawPtr);
+ DALI_TEST_EQUALS(rawPtr->functionCalled, false, TEST_LOCATION);
nonConstPtr->MyFunction();
- DALI_TEST_EQUALS( rawPtr->functionCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(rawPtr->functionCalled, true, TEST_LOCATION);
}
-
// Check if function is called as expected when using a const OwnerPointer
{
- ClassWithFunction* rawPtr2( new ClassWithFunction );
- const Ptr constPtr( rawPtr2 );
- DALI_TEST_EQUALS( rawPtr2->functionCalled, false, TEST_LOCATION );
+ ClassWithFunction* rawPtr2(new ClassWithFunction);
+ const Ptr constPtr(rawPtr2);
+ DALI_TEST_EQUALS(rawPtr2->functionCalled, false, TEST_LOCATION);
constPtr->MyFunction();
- DALI_TEST_EQUALS( rawPtr2->functionCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(rawPtr2->functionCalled, true, TEST_LOCATION);
}
END_TEST;
}
{
// Check the comparison operator
- using Ptr = OwnerPointer< int >;
+ using Ptr = OwnerPointer<int>;
- int* rawIntPtr( new int( 200 ) );
- Ptr ownerPtr( rawIntPtr );
- DALI_TEST_CHECK( ownerPtr == rawIntPtr );
- DALI_TEST_CHECK( ! ( ownerPtr == nullptr ) );
+ int* rawIntPtr(new int(200));
+ Ptr ownerPtr(rawIntPtr);
+ DALI_TEST_CHECK(ownerPtr == rawIntPtr);
+ DALI_TEST_CHECK(!(ownerPtr == nullptr));
END_TEST;
}
bool deleted = false;
- OwnerPointer< OwnedClass > pointer( new OwnedClass( deleted ) );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
+ OwnerPointer<OwnedClass> pointer(new OwnedClass(deleted));
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
pointer.Reset();
- DALI_TEST_EQUALS( deleted, true, TEST_LOCATION );
- DALI_TEST_CHECK( pointer.Get() == nullptr );
+ DALI_TEST_EQUALS(deleted, true, TEST_LOCATION);
+ DALI_TEST_CHECK(pointer.Get() == nullptr);
// Reset the empty pointer, should have no effect but there shouldn't be any crash
pointer.Reset();
- DALI_TEST_CHECK( pointer.Get() == nullptr );
+ DALI_TEST_CHECK(pointer.Get() == nullptr);
END_TEST;
}
bool deleted = false;
- OwnedClass* rawPtr = new OwnedClass( deleted );
- OwnerPointer< OwnedClass > pointer( rawPtr );
+ OwnedClass* rawPtr = new OwnedClass(deleted);
+ OwnerPointer<OwnedClass> pointer(rawPtr);
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( pointer.Release() == rawPtr );
- DALI_TEST_EQUALS( deleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( pointer.Get() == nullptr );
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(pointer.Release() == rawPtr);
+ DALI_TEST_EQUALS(deleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(pointer.Get() == nullptr);
// Release the empty pointer, should have no effect but there shouldn't be any crash
- DALI_TEST_CHECK( pointer.Release() == nullptr );
- DALI_TEST_CHECK( pointer.Get() == nullptr );
+ DALI_TEST_CHECK(pointer.Release() == nullptr);
+ DALI_TEST_CHECK(pointer.Get() == nullptr);
END_TEST;
}
{
// Check the Get method
- using Ptr = OwnerPointer< int >;
+ using Ptr = OwnerPointer<int>;
- int* rawIntPtr( new int( 200 ) );
- Ptr ownerPtr( rawIntPtr );
- DALI_TEST_CHECK( ownerPtr.Get() == rawIntPtr );
+ int* rawIntPtr(new int(200));
+ Ptr ownerPtr(rawIntPtr);
+ DALI_TEST_CHECK(ownerPtr.Get() == rawIntPtr);
END_TEST;
}
{
// Ensure the Swap method swaps the pointers and doesn't delete any objects
- using Ptr = OwnerPointer< OwnedClass >;
+ using Ptr = OwnerPointer<OwnedClass>;
- bool firstObjectDeleted = false;
+ bool firstObjectDeleted = false;
bool secondObjectDeleted = false;
- OwnedClass* firstRawPtr = new OwnedClass( firstObjectDeleted );
- OwnedClass* secondRawPtr = new OwnedClass( secondObjectDeleted );
+ OwnedClass* firstRawPtr = new OwnedClass(firstObjectDeleted);
+ OwnedClass* secondRawPtr = new OwnedClass(secondObjectDeleted);
- Ptr firstPtr( firstRawPtr );
- Ptr secondPtr( secondRawPtr );
+ Ptr firstPtr(firstRawPtr);
+ Ptr secondPtr(secondRawPtr);
// Check initial values
- DALI_TEST_EQUALS( firstObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_EQUALS( secondObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( firstPtr == firstRawPtr );
- DALI_TEST_CHECK( secondPtr == secondRawPtr );
+ DALI_TEST_EQUALS(firstObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(secondObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(firstPtr == firstRawPtr);
+ DALI_TEST_CHECK(secondPtr == secondRawPtr);
// Call Swap on first and ensure swap is done and there's no deletion
- firstPtr.Swap( secondPtr );
- DALI_TEST_EQUALS( firstObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_EQUALS( secondObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( firstPtr == secondRawPtr );
- DALI_TEST_CHECK( secondPtr == firstRawPtr );
+ firstPtr.Swap(secondPtr);
+ DALI_TEST_EQUALS(firstObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(secondObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(firstPtr == secondRawPtr);
+ DALI_TEST_CHECK(secondPtr == firstRawPtr);
// Swap back using second, again no deletion
- secondPtr.Swap( firstPtr );
- DALI_TEST_EQUALS( firstObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_EQUALS( secondObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( firstPtr == firstRawPtr );
- DALI_TEST_CHECK( secondPtr == secondRawPtr );
+ secondPtr.Swap(firstPtr);
+ DALI_TEST_EQUALS(firstObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(secondObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(firstPtr == firstRawPtr);
+ DALI_TEST_CHECK(secondPtr == secondRawPtr);
// Swap with self, nothing should change or be deleted
- firstPtr.Swap( firstPtr );
- DALI_TEST_EQUALS( firstObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( firstPtr == firstRawPtr );
+ firstPtr.Swap(firstPtr);
+ DALI_TEST_EQUALS(firstObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(firstPtr == firstRawPtr);
// Swap with an empty OwnerPointer, no deletion but firstPtr should be empty now
Ptr emptyPtr;
- firstPtr.Swap( emptyPtr );
- DALI_TEST_EQUALS( firstObjectDeleted, false, TEST_LOCATION );
- DALI_TEST_CHECK( firstPtr == nullptr );
- DALI_TEST_CHECK( emptyPtr == firstRawPtr );
+ firstPtr.Swap(emptyPtr);
+ DALI_TEST_EQUALS(firstObjectDeleted, false, TEST_LOCATION);
+ DALI_TEST_CHECK(firstPtr == nullptr);
+ DALI_TEST_CHECK(emptyPtr == firstRawPtr);
END_TEST;
}
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/pinch-gesture-devel.h>
#include <dali/internal/event/events/pinch-gesture/pinch-gesture-impl.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
{
TestApplication application; // Reset all test adapter return codes
- PinchGesture gesture(new Internal::PinchGesture( GestureState::STARTED ));
+ PinchGesture gesture = DevelPinchGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(GestureState::STARTED, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture.GetScale(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture.GetSpeed(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, gesture.GetType(), TEST_LOCATION);
- PinchGesture gesture2(new Internal::PinchGesture( GestureState::CONTINUING ));
+ PinchGesture gesture2 = DevelPinchGesture::New(GestureState::CONTINUING);
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture2.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture2.GetScale(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture2.GetSpeed(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, gesture2.GetType(), TEST_LOCATION);
- PinchGesture gesture3(new Internal::PinchGesture( GestureState::FINISHED ));
+ PinchGesture gesture3 = DevelPinchGesture::New(GestureState::FINISHED);
DALI_TEST_EQUALS(GestureState::FINISHED, gesture3.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture3.GetScale(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture3.GetSpeed(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, gesture3.GetType(), TEST_LOCATION);
// Test copy constructor
- GetImplementation( gesture3 ).SetScale( 3.0f );
- GetImplementation( gesture3 ).SetSpeed( 5.0f );
+ GetImplementation(gesture3).SetScale(3.0f);
+ GetImplementation(gesture3).SetSpeed(5.0f);
PinchGesture pinch(gesture3);
DALI_TEST_EQUALS(GestureState::FINISHED, pinch.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, pinch.GetType(), TEST_LOCATION);
// Test move constructor
- const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
- PinchGesture gesture4( std::move( gesture ) );
+ const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
+ PinchGesture gesture4(std::move(gesture));
DALI_TEST_CHECK(!gesture);
DALI_TEST_EQUALS(GestureType::PINCH, gesture4.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(gesture4.GetBaseObject().ReferenceCount(), refCount, TEST_LOCATION);
int UtcDaliPinchGestureAssignment(void)
{
// Test Assignment operator
- PinchGesture gesture(new Internal::PinchGesture( GestureState::STARTED ));
+ PinchGesture gesture = DevelPinchGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(GestureState::STARTED, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture.GetScale(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture.GetSpeed(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, gesture.GetType(), TEST_LOCATION);
- PinchGesture gesture2(new Internal::PinchGesture( GestureState::CONTINUING ));
+ PinchGesture gesture2 = DevelPinchGesture::New(GestureState::CONTINUING);
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture2.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture2.GetScale(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture2.GetSpeed(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, gesture2.GetType(), TEST_LOCATION);
- GetImplementation( gesture2 ).SetScale( 3.0f );
- GetImplementation( gesture2 ).SetSpeed( 5.0f );
+ GetImplementation(gesture2).SetScale(3.0f);
+ GetImplementation(gesture2).SetSpeed(5.0f);
gesture = gesture2;
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PINCH, gesture.GetType(), TEST_LOCATION);
// Move assignment
- const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
+ const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
PinchGesture gesture3;
DALI_TEST_EQUALS(gesture3, Gesture(), TEST_LOCATION);
gesture3 = std::move(gesture);
int UtcDaliPinchGestureSetGetScaleP(void)
{
- PinchGesture gesture(new Internal::PinchGesture(GestureState::STARTED));
+ PinchGesture gesture = DevelPinchGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetScale(), 0.0f, TEST_LOCATION);
GetImplementation(gesture).SetScale(123.0f);
int UtcDaliPinchGestureSetGetSpeedP(void)
{
- PinchGesture gesture(new Internal::PinchGesture(GestureState::STARTED));
+ PinchGesture gesture = DevelPinchGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetSpeed(), 0.0f, TEST_LOCATION);
GetImplementation(gesture).SetSpeed(123.0f);
int UtcDaliPinchGestureSetGetScreenCenterPointP(void)
{
- PinchGesture gesture(new Internal::PinchGesture(GestureState::STARTED));
+ PinchGesture gesture = DevelPinchGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetScreenCenterPoint(), Vector2::ZERO, TEST_LOCATION);
GetImplementation(gesture).SetScreenCenterPoint(Vector2(123.0f, 321.0f));
- DALI_TEST_EQUALS(gesture.GetScreenCenterPoint(), Vector2(123.0f,321.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(gesture.GetScreenCenterPoint(), Vector2(123.0f, 321.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliPinchGestureSetGetLocalCenterPointP(void)
{
- PinchGesture gesture(new Internal::PinchGesture(GestureState::STARTED));
+ PinchGesture gesture = DevelPinchGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetLocalCenterPoint(), Vector2::ZERO, TEST_LOCATION);
- GetImplementation(gesture).SetLocalCenterPoint(Vector2(123.0f,321.0f));
- DALI_TEST_EQUALS(gesture.GetLocalCenterPoint(), Vector2(123.0f,321.0f), TEST_LOCATION);
+ GetImplementation(gesture).SetLocalCenterPoint(Vector2(123.0f, 321.0f));
+ DALI_TEST_EQUALS(gesture.GetLocalCenterPoint(), Vector2(123.0f, 321.0f), TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
-#include <dali/internal/event/events/pinch-gesture/pinch-gesture-processor.h>
-#include <dali/internal/event/events/pinch-gesture/pinch-gesture-event.h>
#include <dali/internal/event/common/scene-impl.h>
+#include <dali/internal/event/events/pinch-gesture/pinch-gesture-event.h>
+#include <dali/internal/event/events/pinch-gesture/pinch-gesture-processor.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
void TestAbortWithState(GestureState state)
{
TestApplication application;
Internal::PinchGestureProcessor processor;
- Integration::Scene scene( application.GetScene() );
- Internal::Scene& sceneImpl = GetImplementation( scene );
- Internal::PinchGestureEvent event(state);
+ Integration::Scene scene(application.GetScene());
+ Internal::Scene& sceneImpl = GetImplementation(scene);
+ Internal::PinchGestureEvent event(state);
try
{
processor.Process(sceneImpl, event);
- DALI_TEST_CHECK( false ); // Should not get here as we expect an abort
+ DALI_TEST_CHECK(false); // Should not get here as we expect an abort
}
catch(...)
{
- DALI_TEST_CHECK( true ); // We aborted, so the test has passed
+ DALI_TEST_CHECK(true); // We aborted, so the test has passed
}
}
-} // anon namespace
+} // namespace
int UtcDaliPinchGestureProcessorProcessClearStateN(void)
{
TestAbortWithState(GestureState::POSSIBLE);
END_TEST;
}
-
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/rotation-gesture-devel.h>
#include <dali/internal/event/events/rotation-gesture/rotation-gesture-impl.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
{
TestApplication application; // Reset all test adapter return codes
- RotationGesture gesture(new Internal::RotationGesture( GestureState::STARTED ));
+ RotationGesture gesture = DevelRotationGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(GestureState::STARTED, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture.GetRotation().radian, TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture.GetType(), TEST_LOCATION);
- RotationGesture gesture2(new Internal::RotationGesture( GestureState::CONTINUING ));
+ RotationGesture gesture2 = DevelRotationGesture::New(GestureState::CONTINUING);
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture2.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture2.GetRotation().radian, TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture2.GetType(), TEST_LOCATION);
- RotationGesture gesture3(new Internal::RotationGesture( GestureState::FINISHED ));
+ RotationGesture gesture3 = DevelRotationGesture::New(GestureState::FINISHED);
DALI_TEST_EQUALS(GestureState::FINISHED, gesture3.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture3.GetRotation().radian, TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture3.GetType(), TEST_LOCATION);
// Test copy constructor
- GetImplementation( gesture3 ).SetRotation( Radian( 3.0f ));
+ GetImplementation(gesture3).SetRotation(Radian(3.0f));
RotationGesture rotation(gesture3);
DALI_TEST_EQUALS(GestureState::FINISHED, rotation.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, rotation.GetType(), TEST_LOCATION);
// Test move constructor
- const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
- RotationGesture gesture4( std::move( gesture ) );
+ const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
+ RotationGesture gesture4(std::move(gesture));
DALI_TEST_CHECK(!gesture);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture4.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(gesture4.GetBaseObject().ReferenceCount(), refCount, TEST_LOCATION);
int UtcDaliRotationGestureAssignment(void)
{
// Test Assignment operator
- RotationGesture gesture(new Internal::RotationGesture( GestureState::STARTED ));
+ RotationGesture gesture = DevelRotationGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(GestureState::STARTED, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture.GetRotation().radian, TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture.GetType(), TEST_LOCATION);
- RotationGesture gesture2(new Internal::RotationGesture( GestureState::CONTINUING ));
+ RotationGesture gesture2 = DevelRotationGesture::New(GestureState::CONTINUING);
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture2.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.0f, gesture2.GetRotation().radian, TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture2.GetType(), TEST_LOCATION);
- GetImplementation( gesture2 ).SetRotation( Radian( 3.0f ));
+ GetImplementation(gesture2).SetRotation(Radian(3.0f));
gesture = gesture2;
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::ROTATION, gesture.GetType(), TEST_LOCATION);
// Move assignment
- const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
+ const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
RotationGesture gesture3;
DALI_TEST_EQUALS(gesture3, Gesture(), TEST_LOCATION);
gesture3 = std::move(gesture);
int UtcDaliRotationGestureSetGetRotationP(void)
{
- RotationGesture gesture(new Internal::RotationGesture(GestureState::STARTED));
+ RotationGesture gesture = DevelRotationGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetRotation(), Radian(), TEST_LOCATION);
GetImplementation(gesture).SetRotation(Dali::ANGLE_270);
int UtcDaliRotationGestureSetGetScreenCenterPointP(void)
{
- RotationGesture gesture(new Internal::RotationGesture(GestureState::STARTED));
+ RotationGesture gesture = DevelRotationGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetScreenCenterPoint(), Vector2::ZERO, TEST_LOCATION);
- GetImplementation(gesture).SetScreenCenterPoint(Vector2(123.0f,321.0f));
- DALI_TEST_EQUALS(gesture.GetScreenCenterPoint(), Vector2(123.0f,321.0f), TEST_LOCATION);
+ GetImplementation(gesture).SetScreenCenterPoint(Vector2(123.0f, 321.0f));
+ DALI_TEST_EQUALS(gesture.GetScreenCenterPoint(), Vector2(123.0f, 321.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliRotationGestureSetGetLocalCenterPointP(void)
{
- RotationGesture gesture(new Internal::RotationGesture(GestureState::STARTED));
+ RotationGesture gesture = DevelRotationGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetLocalCenterPoint(), Vector2::ZERO, TEST_LOCATION);
- GetImplementation(gesture).SetLocalCenterPoint(Vector2(123.0f,321.0f));
- DALI_TEST_EQUALS(gesture.GetLocalCenterPoint(), Vector2(123.0f,321.0f), TEST_LOCATION);
+ GetImplementation(gesture).SetLocalCenterPoint(Vector2(123.0f, 321.0f));
+ DALI_TEST_EQUALS(gesture.GetLocalCenterPoint(), Vector2(123.0f, 321.0f), TEST_LOCATION);
END_TEST;
}
/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/tap-gesture-devel.h>
#include <dali/internal/event/events/tap-gesture/tap-gesture-impl.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-
// Positive test case for a method
int UtcDaliTapGestureConstructor(void)
{
TestApplication application; // Reset all test adapter return codes
- TapGesture gesture(new Internal::TapGesture( GestureState::STARTED ));
+ TapGesture gesture = DevelTapGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::TAP, gesture.GetType(), TEST_LOCATION);
// Test Copy constructor
- GetImplementation( gesture ).SetNumberOfTouches( 5u );
- GetImplementation( gesture ).SetNumberOfTaps( 2u );
+ GetImplementation(gesture).SetNumberOfTouches(5u);
+ GetImplementation(gesture).SetNumberOfTaps(2u);
TapGesture gesture2(gesture);
DALI_TEST_EQUALS(5u, gesture2.GetNumberOfTouches(), TEST_LOCATION);
// Test move constructor
const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
- TapGesture gesture3( std::move( gesture ) );
+ TapGesture gesture3(std::move(gesture));
DALI_TEST_CHECK(!gesture);
DALI_TEST_EQUALS(GestureType::TAP, gesture3.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(gesture3.GetBaseObject().ReferenceCount(), refCount, TEST_LOCATION);
int UtcDaliTapGestureAssignment(void)
{
// Test Assignment operator
- TapGesture gesture(new Internal::TapGesture( GestureState::STARTED ));
+ TapGesture gesture = DevelTapGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::TAP, gesture.GetType(), TEST_LOCATION);
- GetImplementation( gesture ).SetNumberOfTouches( 5u );
- GetImplementation( gesture ).SetNumberOfTaps( 2u );
+ GetImplementation(gesture).SetNumberOfTouches(5u);
+ GetImplementation(gesture).SetNumberOfTaps(2u);
TapGesture gesture2;
gesture2 = gesture;
int UtcDaliTapGestureSetGetNumberOfTapsP(void)
{
- TapGesture gesture(new Internal::TapGesture(GestureState::STARTED));
+ TapGesture gesture = DevelTapGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetNumberOfTaps(), 1u, TEST_LOCATION);
GetImplementation(gesture).SetNumberOfTaps(123u);
int UtcDaliTapGestureSetGetNumberOfTouchesP(void)
{
- TapGesture gesture(new Internal::TapGesture(GestureState::STARTED));
+ TapGesture gesture = DevelTapGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetNumberOfTouches(), 1u, TEST_LOCATION);
GetImplementation(gesture).SetNumberOfTouches(321u);
int UtcDaliTapGestureSetGetScreenPointP(void)
{
- TapGesture gesture(new Internal::TapGesture(GestureState::STARTED));
+ TapGesture gesture = DevelTapGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2::ZERO, TEST_LOCATION);
- GetImplementation(gesture).SetScreenPoint(Vector2(123.0f,321.0f));
- DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2(123.0f,321.0f), TEST_LOCATION);
+ GetImplementation(gesture).SetScreenPoint(Vector2(123.0f, 321.0f));
+ DALI_TEST_EQUALS(gesture.GetScreenPoint(), Vector2(123.0f, 321.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliTapGestureSetGetLocalPointP(void)
{
- TapGesture gesture(new Internal::TapGesture(GestureState::STARTED));
+ TapGesture gesture = DevelTapGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2::ZERO, TEST_LOCATION);
- GetImplementation(gesture).SetLocalPoint(Vector2(123.0f,321.0f));
- DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2(123.0f,321.0f), TEST_LOCATION);
+ GetImplementation(gesture).SetLocalPoint(Vector2(123.0f, 321.0f));
+ DALI_TEST_EQUALS(gesture.GetLocalPoint(), Vector2(123.0f, 321.0f), TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
-#include <dali/internal/event/events/tap-gesture/tap-gesture-processor.h>
-#include <dali/internal/event/events/tap-gesture/tap-gesture-event.h>
#include <dali/internal/event/common/scene-impl.h>
+#include <dali/internal/event/events/tap-gesture/tap-gesture-event.h>
+#include <dali/internal/event/events/tap-gesture/tap-gesture-processor.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
void TestAbortWithState(GestureState state)
{
TestApplication application;
Internal::TapGestureProcessor processor;
- Integration::Scene scene( application.GetScene() );
- Internal::Scene& sceneImpl = GetImplementation( scene );
- Internal::TapGestureEvent event(state);
+ Integration::Scene scene(application.GetScene());
+ Internal::Scene& sceneImpl = GetImplementation(scene);
+ Internal::TapGestureEvent event(state);
try
{
processor.Process(sceneImpl, event);
- DALI_TEST_CHECK( false ); // Should not get here as we expect an abort
+ DALI_TEST_CHECK(false); // Should not get here as we expect an abort
}
catch(...)
{
- DALI_TEST_CHECK( true ); // We aborted, so the test has passed
+ DALI_TEST_CHECK(true); // We aborted, so the test has passed
}
}
-} // anon namespace
+} // namespace
int UtcDaliTapGestureProcessorProcessClearStateN(void)
{
TestAbortWithState(GestureState::FINISHED);
END_TEST;
}
-
// First TET_PASS should set to zero
// first TET_FAIL should prevent any further TET_PASS from setting back to zero
// Any TET_FAIL should set to fail or leave as fail
- if( test_return_value != 1 )
+ if(test_return_value != 1)
test_return_value = value;
}
#define END_TEST \
- return ((test_return_value>0)?1:0)
+ return ((test_return_value > 0) ? 1 : 0)
extern "C"
{
+ void tet_infoline(const char* str)
+ {
+ fprintf(stderr, "%s\n", str);
+ }
-void tet_infoline(const char* str)
-{
- fprintf(stderr, "%s\n", str);
-}
-
-void tet_printf(const char *format, ...)
-{
- va_list arg;
- va_start(arg, format);
- vfprintf(stderr, format, arg);
- va_end(arg);
-}
+ void tet_printf(const char* format, ...)
+ {
+ va_list arg;
+ va_start(arg, format);
+ vfprintf(stderr, format, arg);
+ va_end(arg);
+ }
}
-
bool operator==(TimePeriod a, TimePeriod b)
{
- return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds) ;
+ return Equals(a.durationSeconds, b.durationSeconds) && Equals(a.delaySeconds, b.delaySeconds);
}
-std::ostream& operator<<( std::ostream& ostream, TimePeriod value )
+std::ostream& operator<<(std::ostream& ostream, TimePeriod value)
{
return ostream << "( Duration:" << value.durationSeconds << " Delay:" << value.delaySeconds << ")";
}
-std::ostream& operator<<( std::ostream& ostream, Radian angle )
+std::ostream& operator<<(std::ostream& ostream, Radian angle)
{
ostream << angle.radian;
return ostream;
}
-std::ostream& operator<<( std::ostream& ostream, Degree angle )
+std::ostream& operator<<(std::ostream& ostream, Degree angle)
{
ostream << angle.degree;
return ostream;
}
-void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location )
+void DALI_TEST_EQUALS(const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location)
{
- DALI_TEST_EQUALS< const BaseHandle& >( baseHandle1, baseHandle2, location );
+ DALI_TEST_EQUALS<const BaseHandle&>(baseHandle1, baseHandle2, location);
}
-void DALI_TEST_EQUALS( const size_t value1, const uint32_t value2, const char* location )
+void DALI_TEST_EQUALS(const size_t value1, const uint32_t value2, const char* location)
{
- DALI_TEST_EQUALS< uint32_t >( ( uint32_t )( value1 ), value2, location );
+ DALI_TEST_EQUALS<uint32_t>((uint32_t)(value1), value2, location);
}
-void DALI_TEST_EQUALS( const uint32_t value1, const size_t value2, const char* location )
+void DALI_TEST_EQUALS(const uint32_t value1, const size_t value2, const char* location)
{
- DALI_TEST_EQUALS< uint32_t >( value1, ( uint32_t )( value2 ), location );
+ DALI_TEST_EQUALS<uint32_t>(value1, (uint32_t)(value2), location);
}
-void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location)
+void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, const char* location)
{
- const float* m1 = matrix1.AsFloat();
- const float* m2 = matrix2.AsFloat();
- bool equivalent = true;
+ const float* m1 = matrix1.AsFloat();
+ const float* m2 = matrix2.AsFloat();
+ bool equivalent = true;
- for (int32_t i=0;i<9;++i)
+ for(int32_t i = 0; i < 9; ++i)
{
- if( ! (fabsf(m1[i] - m2[i])< GetRangedEpsilon(m1[i], m2[i])) )
+ if(!(fabsf(m1[i] - m2[i]) < GetRangedEpsilon(m1[i], m2[i])))
{
equivalent = false;
}
}
- if( !equivalent )
+ if(!equivalent)
{
// Align each float to 1234.67, i.e. 3.6 will be " 3.60"
- fprintf( stderr, "%s, checking\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
- location,
- m1[0], m1[3], m1[6], m2[0], m2[3], m2[6],
- m1[1], m1[4], m1[7], m2[1], m2[4], m2[7],
- m1[2], m1[5], m1[8], m2[2], m2[5], m2[8] );
+ // clang-format off
+ fprintf(stderr, "%s, checking\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
+ location,
+ m1[0],m1[3],m1[6],m2[0],m2[3],m2[6],
+ m1[1],m1[4],m1[7],m2[1],m2[4],m2[7],
+ m1[2],m1[5],m1[8],m2[2],m2[5],m2[8]);
+ // clang-format on
tet_result(TET_FAIL);
throw("TET_FAIL");
}
}
-void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location)
+void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location)
{
- const float* m1 = matrix1.AsFloat();
- const float* m2 = matrix2.AsFloat();
- bool equivalent = true;
+ const float* m1 = matrix1.AsFloat();
+ const float* m2 = matrix2.AsFloat();
+ bool equivalent = true;
- for (int32_t i=0;i<9;++i)
+ for(int32_t i = 0; i < 9; ++i)
{
- equivalent &= (fabsf(m1[i] - m2[i])<epsilon);
+ equivalent &= (fabsf(m1[i] - m2[i]) < epsilon);
}
- if (!equivalent)
+ if(!equivalent)
{
// Align each float to 1234.67, i.e. 3.6 will be " 3.60"
- fprintf( stderr, "%s, checking\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
- location,
- m1[0], m1[3], m1[6], m2[0], m2[3], m2[6],
- m1[1], m1[4], m1[7], m2[1], m2[4], m2[7],
- m1[2], m1[5], m1[8], m2[2], m2[5], m2[8] );
+ // clang-format off
+ fprintf(stderr, "%s, checking\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
+ location,
+ m1[0],m1[3],m1[6],m2[0],m2[3],m2[6],
+ m1[1],m1[4],m1[7],m2[1],m2[4],m2[7],
+ m1[2],m1[5],m1[8],m2[2],m2[5],m2[8]);
+ // clang-format on
tet_result(TET_FAIL);
throw("TET_FAIL");
}
}
-void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location)
+void DALI_TEST_EQUALS(const Matrix& matrix1, const Matrix& matrix2, const char* location)
{
- const float* m1 = matrix1.AsFloat();
- const float* m2 = matrix2.AsFloat();
- bool identical = true;
+ const float* m1 = matrix1.AsFloat();
+ const float* m2 = matrix2.AsFloat();
+ bool identical = true;
int32_t i;
- for (i=0;i<16;++i)
+ for(i = 0; i < 16; ++i)
{
if(m1[i] != m2[i])
{
}
}
- if (!identical)
+ if(!identical)
{
// Align each float to 1234.67, i.e. 3.6 will be " 3.60"
- fprintf( stderr, "%s, checking\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
- location,
- m1[0], m1[4], m1[8], m1[12], m2[0], m2[4], m2[8], m2[12],
- m1[1], m1[5], m1[9], m1[13], m2[1], m2[5], m2[9], m2[13],
- m1[2], m1[6], m1[10], m1[14], m2[2], m2[6], m2[10], m2[14],
- m1[3], m1[7], m1[11], m1[15], m2[3], m2[7], m2[11], m2[15] );
+ // clang-format off
+ fprintf(stderr, "%s, checking\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
+ location,
+ m1[0],m1[4],m1[8],m1[12],m2[0],m2[4],m2[8],m2[12],
+ m1[1],m1[5],m1[9],m1[13],m2[1],m2[5],m2[9],m2[13],
+ m1[2],m1[6],m1[10],m1[14],m2[2],m2[6],m2[10],m2[14],
+ m1[3],m1[7],m1[11],m1[15],m2[3],m2[7],m2[11],m2[15]);
+ // clang-format on
tet_result(TET_FAIL);
throw("TET_FAIL");
}
}
-void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location)
+void DALI_TEST_EQUALS(const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location)
{
- const float* m1 = matrix1.AsFloat();
- const float* m2 = matrix2.AsFloat();
- bool equivalent = true;
+ const float* m1 = matrix1.AsFloat();
+ const float* m2 = matrix2.AsFloat();
+ bool equivalent = true;
- for (int32_t i=0;i<16;++i)
+ for(int32_t i = 0; i < 16; ++i)
{
- equivalent &= (fabsf(m1[i] - m2[i])<epsilon);
+ equivalent &= (fabsf(m1[i] - m2[i]) < epsilon);
}
- if (!equivalent)
+ if(!equivalent)
{
// Align each float to 1234.67, i.e. 3.6 will be " 3.60"
- fprintf( stderr, "%s, checking\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
- "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
- location,
- m1[0], m1[4], m1[8], m1[12], m2[0], m2[4], m2[8], m2[12],
- m1[1], m1[5], m1[9], m1[13], m2[1], m2[5], m2[9], m2[13],
- m1[2], m1[6], m1[10], m1[14], m2[2], m2[6], m2[10], m2[14],
- m1[3], m1[7], m1[11], m1[15], m2[3], m2[7], m2[11], m2[15] );
+ // clang-format off
+ fprintf(stderr, "%s, checking\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f == %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n"
+ "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
+ location,
+ m1[0],m1[4],m1[8],m1[12],m2[0],m2[4],m2[8],m2[12],
+ m1[1],m1[5],m1[9],m1[13],m2[1],m2[5],m2[9],m2[13],
+ m1[2],m1[6],m1[10],m1[14],m2[2],m2[6],m2[10],m2[14],
+ m1[3],m1[7],m1[11],m1[15],m2[3],m2[7],m2[11],m2[15]);
+ // clang-format on
tet_result(TET_FAIL);
throw("TET_FAIL");
}
}
-
/**
* Test whether two strings are equal.
* @param[in] str1 The first string
* @param[in] str2 The second string
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location)
+void DALI_TEST_EQUALS(const std::string& str1, const char* str2, const char* location)
{
DALI_TEST_EQUALS(str1.c_str(), str2, location);
}
-void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location)
+void DALI_TEST_EQUALS(Property::Value& str1, const char* str2, const char* location)
{
bool result = false;
- if( str1.GetType() == Property::STRING )
+ if(str1.GetType() == Property::STRING)
{
std::string string;
str1.Get(string);
result = !string.compare(str2);
}
- if( result )
+ if(result)
{
tet_result(TET_PASS);
}
}
}
-void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location)
+void DALI_TEST_EQUALS(const char* str1, const std::string& str2, const char* location)
{
DALI_TEST_EQUALS(str1, str2.c_str(), location);
}
-void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location )
+void DALI_TEST_ASSERT(DaliException& e, std::string conditionSubString, const char* location)
{
- if( NULL == strstr( e.condition, conditionSubString.c_str() ) )
+ if(NULL == strstr(e.condition, conditionSubString.c_str()))
{
- fprintf(stderr, "Expected substring '%s' : actual exception string '%s' : location %s\n", conditionSubString.c_str(), e.condition, location );
+ fprintf(stderr, "Expected substring '%s' : actual exception string '%s' : location %s\n", conditionSubString.c_str(), e.condition, location);
tet_result(TET_FAIL);
throw("TET_FAIL");
}
}
// Functor to test whether an Applied signal is emitted
-ConstraintAppliedCheck::ConstraintAppliedCheck( bool& signalReceived )
-: mSignalReceived( signalReceived )
+ConstraintAppliedCheck::ConstraintAppliedCheck(bool& signalReceived)
+: mSignalReceived(signalReceived)
{
}
-void ConstraintAppliedCheck::operator()( Constraint& constraint )
+void ConstraintAppliedCheck::operator()(Constraint& constraint)
{
mSignalReceived = true;
}
void ConstraintAppliedCheck::CheckSignalReceived()
{
- if ( !mSignalReceived )
+ if(!mSignalReceived)
{
- fprintf(stderr, "Expected Applied signal was not received\n" );
- tet_result( TET_FAIL );
+ fprintf(stderr, "Expected Applied signal was not received\n");
+ tet_result(TET_FAIL);
throw("TET_FAIL");
}
else
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
}
void ConstraintAppliedCheck::CheckSignalNotReceived()
{
- if ( mSignalReceived )
+ if(mSignalReceived)
{
- fprintf(stderr, "Unexpected Applied signal was received\n" );
- tet_result( TET_FAIL );
+ fprintf(stderr, "Unexpected Applied signal was received\n");
+ tet_result(TET_FAIL);
throw("TET_FAIL");
}
else
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
}
namespace Test
{
-
struct ObjectDestructionFunctor
{
// Create a ObjectDestructionFunctor passing in a Dali::RefObject* to be monitored and a bool variable.
// Create ObjectRegistry instance and connect to the ObjectDestroyedSignal passing in the above functor for the callback.
// Get the ObjectPointer (Actor::GetObjectPtr) of the Actor to be checked for destruction and assign it to the Dali::RefObject*
// Check the bool variable which would be true when object destroyed.
- ObjectDestructionFunctor( Dali::RefObject* objectPtr, bool& refObjectDestroyed )
- : refObjectPointerToCheck( objectPtr ),
- refObjectDestroyedBoolean( refObjectDestroyed )
+ ObjectDestructionFunctor(Dali::RefObject* objectPtr, bool& refObjectDestroyed)
+ : refObjectPointerToCheck(objectPtr),
+ refObjectDestroyedBoolean(refObjectDestroyed)
{
refObjectDestroyed = false;
}
- void operator()( const Dali::RefObject* objectPointer )
+ void operator()(const Dali::RefObject* objectPointer)
{
- if ( refObjectPointerToCheck == objectPointer )
+ if(refObjectPointerToCheck == objectPointer)
{
refObjectDestroyedBoolean = true;
}
}
Dali::RefObject* refObjectPointerToCheck;
- bool& refObjectDestroyedBoolean;
+ bool& refObjectDestroyedBoolean;
};
-ObjectDestructionTracker::ObjectDestructionTracker( ObjectRegistry objectRegistry )
-: mObjectRegistry( objectRegistry ),
- mRefObjectDestroyed( false)
+ObjectDestructionTracker::ObjectDestructionTracker(ObjectRegistry objectRegistry)
+: mObjectRegistry(objectRegistry),
+ mRefObjectDestroyed(false)
{
}
-void ObjectDestructionTracker::Start( Actor actor )
+void ObjectDestructionTracker::Start(Actor actor)
{
- ObjectDestructionFunctor destructionFunctor( actor.GetObjectPtr(), mRefObjectDestroyed );
- mObjectRegistry.ObjectDestroyedSignal().Connect( this, destructionFunctor );
+ ObjectDestructionFunctor destructionFunctor(actor.GetObjectPtr(), mRefObjectDestroyed);
+ mObjectRegistry.ObjectDestroyedSignal().Connect(this, destructionFunctor);
}
bool ObjectDestructionTracker::IsDestroyed()
{
- return mRefObjectDestroyed;
+ return mRefObjectDestroyed;
}
} // namespace Test
// EXTERNAL INCLUDES
#include <cstdarg>
#include <cstdio>
-#include <iostream>
#include <cstring>
+#include <iostream>
#include <string>
// INTERNAL INCLUDES
extern "C"
{
-void tet_infoline(const char*str);
-void tet_printf(const char *format, ...);
+ void tet_infoline(const char* str);
+ void tet_printf(const char* format, ...);
}
-#include "test-application.h"
#include "test-actor-utils.h"
+#include "test-application.h"
#include "test-gesture-generator.h"
using namespace Dali;
* Inspired by https://stackoverflow.com/questions/1706346/file-macro-manipulation-handling-at-compile-time
* answer by Chetan Reddy
*/
-constexpr int32_t basenameIndex( const char * const path, const int32_t index = 0, const int32_t slashIndex = -1 )
+constexpr int32_t basenameIndex(const char* const path, const int32_t index = 0, const int32_t slashIndex = -1)
{
- return path[ index ]
- ? ( path[ index ] == '/'
- ? basenameIndex( path, index + 1, index )
- : basenameIndex( path, index + 1, slashIndex ) )
- : ( slashIndex + 1 );
+ return path[index]
+ ? (path[index] == '/'
+ ? basenameIndex(path, index + 1, index)
+ : basenameIndex(path, index + 1, slashIndex))
+ : (slashIndex + 1);
}
-#define __FILELINE__ ( { static const int32_t basenameIdx = basenameIndex( __FILE__ ); \
+#define __FILELINE__ ({ static const int32_t basenameIdx = basenameIndex( __FILE__ ); \
static_assert (basenameIdx >= 0, "compile-time basename" ); \
- __FILE__ ":" STRINGIZE(__LINE__) + basenameIdx ; } )
+ __FILE__ ":" STRINGIZE(__LINE__) + basenameIdx ; })
#define TEST_LOCATION __FILELINE__
-#define TEST_INNER_LOCATION(x) ( std::string(x) + " (" + STRINGIZE(__LINE__) + ")" ).c_str()
+#define TEST_INNER_LOCATION(x) (std::string(x) + " (" + STRINGIZE(__LINE__) + ")").c_str()
#define TET_UNDEF 2
#define TET_FAIL 1
void tet_result(int32_t value);
#define END_TEST \
- return ((test_return_value>0)?1:0)
+ return ((test_return_value > 0) ? 1 : 0)
void tet_infoline(const char* str);
-void tet_printf(const char *format, ...);
+void tet_printf(const char* format, ...);
/**
* DALI_TEST_CHECK is a wrapper for tet_result.
* If the condition evaluates to false, the test is stopped.
* @param[in] The boolean expression to check
*/
-#define DALI_TEST_CHECK(condition) \
-if ( (condition) ) \
-{ \
- tet_result(TET_PASS); \
-} \
-else \
-{ \
- fprintf(stderr, "Test failed in %s, condition: %s\n", __FILELINE__, #condition ); \
- tet_result(TET_FAIL); \
- throw("TET_FAIL"); \
-}
-
+#define DALI_TEST_CHECK(condition) \
+ if((condition)) \
+ { \
+ tet_result(TET_PASS); \
+ } \
+ else \
+ { \
+ fprintf(stderr, "Test failed in %s, condition: %s\n", __FILELINE__, #condition); \
+ tet_result(TET_FAIL); \
+ throw("TET_FAIL"); \
+ }
-bool operator==(TimePeriod a, TimePeriod b);
-std::ostream& operator<<( std::ostream& ostream, TimePeriod value );
-std::ostream& operator<<( std::ostream& ostream, Radian angle );
-std::ostream& operator<<( std::ostream& ostream, Degree angle );
+bool operator==(TimePeriod a, TimePeriod b);
+std::ostream& operator<<(std::ostream& ostream, TimePeriod value);
+std::ostream& operator<<(std::ostream& ostream, Radian angle);
+std::ostream& operator<<(std::ostream& ostream, Degree angle);
/**
* Test whether two values are equal.
template<typename Type>
inline void DALI_TEST_EQUALS(Type value1, Type value2, const char* location)
{
- if( !CompareType<Type>(value1, value2, 0.01f) )
+ if(!CompareType<Type>(value1, value2, 0.01f))
{
std::ostringstream o;
o << value1 << " == " << value2 << std::endl;
fprintf(stderr, "Test failed in %s, checking %s", location, o.str().c_str());
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
else
{
* @param[in] value1 The first value
* @param[in] value2 The second value
*/
-#define DALI_TEST_EQUAL( v1, v2 ) DALI_TEST_EQUALS( v1, v2, __FILELINE__ )
+#define DALI_TEST_EQUAL(v1, v2) DALI_TEST_EQUALS(v1, v2, __FILELINE__)
template<typename Type>
inline void DALI_TEST_EQUALS(Type value1, Type value2, float epsilon, const char* location)
{
- if( !CompareType<Type>(value1, value2, epsilon) )
+ if(!CompareType<Type>(value1, value2, epsilon))
{
std::ostringstream o;
o << value1 << " == " << value2 << std::endl;
fprintf(stderr, "Test failed in %s, checking %s", location, o.str().c_str());
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
else
{
template<typename Type>
inline void DALI_TEST_NOT_EQUALS(Type value1, Type value2, float epsilon, const char* location)
{
- if( CompareType<Type>(value1, value2, epsilon) )
+ if(CompareType<Type>(value1, value2, epsilon))
{
std::ostringstream o;
o << value1 << " != " << value2 << std::endl;
fprintf(stderr, "Test failed in %s, checking %s", location, o.str().c_str());
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
else
{
}
}
-
/**
* Test whether two TimePeriods are within a certain distance of each other.
* @param[in] value1 The first value
* @param[in] location The TEST_LOCATION macro should be used here
*/
template<>
-inline void DALI_TEST_EQUALS<TimePeriod>( TimePeriod value1, TimePeriod value2, float epsilon, const char* location)
+inline void DALI_TEST_EQUALS<TimePeriod>(TimePeriod value1, TimePeriod value2, float epsilon, const char* location)
{
- if ((fabs(value1.durationSeconds - value2.durationSeconds) > epsilon))
+ if((fabs(value1.durationSeconds - value2.durationSeconds) > epsilon))
{
fprintf(stderr, "Test failed in %s, checking durations %f == %f, epsilon %f\n", location, value1.durationSeconds, value2.durationSeconds, epsilon);
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
- else if ((fabs(value1.delaySeconds - value2.delaySeconds) > epsilon))
+ else if((fabs(value1.delaySeconds - value2.delaySeconds) > epsilon))
{
fprintf(stderr, "Test failed in %s, checking delays %f == %f, epsilon %f\n", location, value1.delaySeconds, value2.delaySeconds, epsilon);
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
else
{
* @param[in] baseHandle2 The second value
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location );
+void DALI_TEST_EQUALS(const BaseHandle& baseHandle1, const BaseHandle& baseHandle2, const char* location);
/**
* Test whether a size_t value and an uint32_t are equal.
* @param[in] value2 The second value
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const size_t value1, const uint32_t value2, const char* location );
+void DALI_TEST_EQUALS(const size_t value1, const uint32_t value2, const char* location);
/**
* Test whether an uint32_t and a size_t value and are equal.
* @param[in] value2 The second value
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const uint32_t value1, const size_t value2, const char* location );
+void DALI_TEST_EQUALS(const uint32_t value1, const size_t value2, const char* location);
/**
* Test whether two Matrix3 objects are equal.
* @param[in] matrix2 The second object
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, const char* location);
+void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, const char* location);
/** Test whether two Matrix3 objects are equal (fuzzy compare).
* @param[in] matrix1 The first object
* @param[in] epsilon The epsilon to use for comparison
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location);
+void DALI_TEST_EQUALS(const Matrix3& matrix1, const Matrix3& matrix2, float epsilon, const char* location);
/**
* Test whether two Matrix objects are equal.
* @param[in] matrix2 The second object
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, const char* location);
+void DALI_TEST_EQUALS(const Matrix& matrix1, const Matrix& matrix2, const char* location);
/**
* Test whether two Matrix objects are equal (fuzzy-compare).
* @param[in] matrix2 The second object
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location);
+void DALI_TEST_EQUALS(const Matrix& matrix1, const Matrix& matrix2, float epsilon, const char* location);
/**
* Test whether two strings are equal.
* @param[in] location The TEST_LOCATION macro should be used here
*/
template<>
-inline void DALI_TEST_EQUALS<const char*>( const char* str1, const char* str2, const char* location)
+inline void DALI_TEST_EQUALS<const char*>(const char* str1, const char* str2, const char* location)
{
- if (strcmp(str1, str2))
+ if(strcmp(str1, str2))
{
fprintf(stderr, "Test failed in %s, checking '%s' == '%s'\n", location, str1, str2);
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
else
{
* @param[in] location The TEST_LOCATION macro should be used here
*/
template<>
-inline void DALI_TEST_EQUALS<const std::string&>( const std::string &str1, const std::string &str2, const char* location)
+inline void DALI_TEST_EQUALS<const std::string&>(const std::string& str1, const std::string& str2, const char* location)
{
DALI_TEST_EQUALS(str1.c_str(), str2.c_str(), location);
}
* @param[in] str2 The second string
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( Property::Value& str1, const char* str2, const char* location);
+void DALI_TEST_EQUALS(Property::Value& str1, const char* str2, const char* location);
/**
* Test whether two strings are equal.
* @param[in] str2 The second string
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const std::string &str1, const char* str2, const char* location);
+void DALI_TEST_EQUALS(const std::string& str1, const char* str2, const char* location);
/**
* Test whether two strings are equal.
* @param[in] str2 The second string
* @param[in] location The TEST_LOCATION macro should be used here
*/
-void DALI_TEST_EQUALS( const char* str1, const std::string &str2, const char* location);
+void DALI_TEST_EQUALS(const char* str1, const std::string& str2, const char* location);
/**
* Test if a property value type is equal to a trivial type.
*/
template<typename Type>
-inline void DALI_TEST_VALUE_EQUALS( Property::Value&& value1, Type value2, float epsilon, const char* location)
+inline void DALI_TEST_VALUE_EQUALS(Property::Value&& value1, Type value2, float epsilon, const char* location)
{
Property::Value value2b(value2);
DALI_TEST_EQUALS(value1, value2b, epsilon, location);
}
-
/**
* Test whether one unsigned integer value is greater than another.
* Test succeeds if value1 > value2
* @param[in] value2 The second value
* @param[in] location The TEST_LOCATION macro should be used here
*/
-template< typename T >
-void DALI_TEST_GREATER( T value1, T value2, const char* location)
+template<typename T>
+void DALI_TEST_GREATER(T value1, T value2, const char* location)
{
- if (!(value1 > value2))
+ if(!(value1 > value2))
{
- std::cerr << "Test failed in " << location << ", checking " << value1 <<" > " << value2 << "\n";
+ std::cerr << "Test failed in " << location << ", checking " << value1 << " > " << value2 << "\n";
tet_result(TET_FAIL);
- throw("TET_FAIL"); \
+ throw("TET_FAIL");
}
else
{
* assertion which triggered the exception.
* @param[in] location The TEST_LOCATION macro should be used here.
*/
-void DALI_TEST_ASSERT( DaliException& e, std::string conditionSubString, const char* location );
+void DALI_TEST_ASSERT(DaliException& e, std::string conditionSubString, const char* location);
/**
* Print the assert
* @param[in] e The exception that we expect was fired by a runtime assertion failure.
*/
-inline void DALI_TEST_PRINT_ASSERT( DaliException& e )
+inline void DALI_TEST_PRINT_ASSERT(DaliException& e)
{
- tet_printf("Assertion %s failed at %s\n", e.condition, e.location );
+ tet_printf("Assertion %s failed at %s\n", e.condition, e.location);
}
/**
* @param expressions code to execute
* @param assertstring the substring expected in the assert
*/
-#define DALI_TEST_ASSERTION( expressions, assertstring ) \
-try \
-{ \
- TestApplication::EnableLogging( false ); \
- expressions; \
- TestApplication::EnableLogging( true ); \
- fprintf(stderr, "Test failed in %s, expected assert: '%s' didn't occur\n", __FILELINE__, assertstring ); \
- tet_result(TET_FAIL); \
- throw("TET_FAIL"); } \
-catch( Dali::DaliException& e ) \
-{ \
- DALI_TEST_ASSERT( e, assertstring, TEST_LOCATION ); \
-}
+#define DALI_TEST_ASSERTION(expressions, assertstring) \
+ try \
+ { \
+ TestApplication::EnableLogging(false); \
+ expressions; \
+ TestApplication::EnableLogging(true); \
+ fprintf(stderr, "Test failed in %s, expected assert: '%s' didn't occur\n", __FILELINE__, assertstring); \
+ tet_result(TET_FAIL); \
+ throw("TET_FAIL"); \
+ } \
+ catch(Dali::DaliException & e) \
+ { \
+ DALI_TEST_ASSERT(e, assertstring, TEST_LOCATION); \
+ }
// Functor to test whether an Applied signal is emitted
struct ConstraintAppliedCheck
{
- ConstraintAppliedCheck( bool& signalReceived );
- void operator()( Constraint& constraint );
- void Reset();
- void CheckSignalReceived();
- void CheckSignalNotReceived();
+ ConstraintAppliedCheck(bool& signalReceived);
+ void operator()(Constraint& constraint);
+ void Reset();
+ void CheckSignalReceived();
+ void CheckSignalNotReceived();
bool& mSignalReceived; // owned by individual tests
};
/**
* A Helper to test default functions
*/
-template <typename T>
+template<typename T>
struct DefaultFunctionCoverage
{
DefaultFunctionCoverage()
{
- T a;
- T *b = new T(a);
+ T a;
+ T* b = new T(a);
DALI_TEST_CHECK(b);
a = *b;
delete b;
class ObjectDestructionTracker : public ConnectionTracker
{
public:
-
/**
* @brief Call in main part of code
* @param[in] objectRegistry The object Registry being used
*/
- ObjectDestructionTracker( ObjectRegistry objectRegistry );
+ ObjectDestructionTracker(ObjectRegistry objectRegistry);
/**
* @brief Call in sub bock of code where the Actor being checked is still alive.
*
* @param[in] actor Actor to be checked for destruction
*/
- void Start( Actor actor );
+ void Start(Actor actor);
/**
* @brief Call to check if Actor alive or destroyed.
private:
ObjectRegistry mObjectRegistry;
- bool mRefObjectDestroyed;
+ bool mRefObjectDestroyed;
};
} // namespace Test
namespace Dali
{
-
Shader CreateShader()
{
- return Shader::New( "vertexSrc", "fragmentSrc" );
+ return Shader::New("vertexSrc", "fragmentSrc");
}
TextureSet CreateTextureSet()
return TextureSet::New();
}
-TextureSet CreateTextureSet( Texture texture )
+TextureSet CreateTextureSet(Texture texture)
{
TextureSet textureSet = TextureSet::New();
textureSet.SetTexture(0u, texture);
VertexBuffer CreateVertexBuffer()
{
Property::Map texturedQuadVertexFormat;
- texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
+ texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
texturedQuadVertexFormat["aVertexCoord"] = Property::VECTOR2;
- VertexBuffer vertexData = VertexBuffer::New( texturedQuadVertexFormat );
+ VertexBuffer vertexData = VertexBuffer::New(texturedQuadVertexFormat);
return vertexData;
}
Geometry CreateQuadGeometry(void)
{
- VertexBuffer vertexData = CreateVertexBuffer();
- const float halfQuadSize = .5f;
- struct TexturedQuadVertex { Vector2 position; Vector2 textureCoordinates; };
+ VertexBuffer vertexData = CreateVertexBuffer();
+ const float halfQuadSize = .5f;
+ struct TexturedQuadVertex
+ {
+ Vector2 position;
+ Vector2 textureCoordinates;
+ };
TexturedQuadVertex texturedQuadVertexData[4] = {
- { Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f) },
- { Vector2( halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f) },
- { Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f) },
- { Vector2( halfQuadSize, halfQuadSize), Vector2(1.f, 1.f) } };
+ {Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f)},
+ {Vector2(halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f)},
+ {Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f)},
+ {Vector2(halfQuadSize, halfQuadSize), Vector2(1.f, 1.f)}};
vertexData.SetData(texturedQuadVertexData, 4);
- unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
+ unsigned short indexData[6] = {0, 3, 1, 0, 2, 3};
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexData );
- geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
+ geometry.AddVertexBuffer(vertexData);
+ geometry.SetIndexBuffer(indexData, sizeof(indexData) / sizeof(indexData[0]));
return geometry;
}
-
-
} // namespace Dali
namespace Dali
{
-
-Shader CreateShader();
-TextureSet CreateTextureSet();
-TextureSet CreateTextureSet( Texture texture );
-Geometry CreateQuadGeometry();
+Shader CreateShader();
+TextureSet CreateTextureSet();
+TextureSet CreateTextureSet(Texture texture);
+Geometry CreateQuadGeometry();
VertexBuffer CreateVertexBuffer();
-}
+} // namespace Dali
#endif // MESH_BUILDER_H
namespace Dali
{
-
namespace
{
-
const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
- attribute mediump vec2 aPosition;\n
- uniform mediump mat4 uMvpMatrix;\n
- uniform mediump vec3 uSize;\n
- \n
- void main()\n
- {\n
- mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);\n
- vertexPosition.xyz *= uSize;\n
- gl_Position = uMvpMatrix * vertexPosition;\n
- }\n
-);
+ attribute mediump vec2 aPosition;\n
+ uniform mediump mat4 uMvpMatrix;\n
+ uniform mediump vec3 uSize;\n
+ \n void main()\n {
+ \n
+ mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
+ \n
+ vertexPosition.xyz *= uSize;
+ \n
+ gl_Position = uMvpMatrix * vertexPosition;
+ \n
+ }\n);
const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
uniform lowp vec4 uColor;\n
- \n
- void main()\n
- {\n
- gl_FragColor = uColor;\n
- }\n
-);
+ \n void main()\n {
+ \n
+ gl_FragColor = uColor;
+ \n
+ }\n);
} // unnamed namespace
Actor CreateRenderableActor()
{
- return CreateRenderableActor( Texture(), VERTEX_SHADER, FRAGMENT_SHADER );
+ return CreateRenderableActor(Texture(), VERTEX_SHADER, FRAGMENT_SHADER);
}
-Actor CreateRenderableActor( Texture texture )
+Actor CreateRenderableActor(Texture texture)
{
- return CreateRenderableActor( texture, VERTEX_SHADER, FRAGMENT_SHADER );
+ return CreateRenderableActor(texture, VERTEX_SHADER, FRAGMENT_SHADER);
}
-Actor CreateRenderableActor( Texture texture, const std::string& vertexShader, const std::string& fragmentShader )
+Actor CreateRenderableActor(Texture texture, const std::string& vertexShader, const std::string& fragmentShader)
{
// Create the geometry
Geometry geometry = CreateQuadGeometry();
// Create Shader
- Shader shader = Shader::New( vertexShader, fragmentShader );
+ Shader shader = Shader::New(vertexShader, fragmentShader);
// Create renderer from geometry and material
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
// Create actor and set renderer
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
+ actor.AddRenderer(renderer);
// If we a texture, then create a texture-set and add to renderer
- if( texture )
+ if(texture)
{
TextureSet textureSet = TextureSet::New();
- textureSet.SetTexture( 0u, texture );
- renderer.SetTextures( textureSet );
+ textureSet.SetTexture(0u, texture);
+ renderer.SetTextures(textureSet);
// Set actor to the size of the texture if set
- actor.SetProperty( Actor::Property::SIZE, Vector2( texture.GetWidth(), texture.GetHeight() ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(texture.GetWidth(), texture.GetHeight()));
}
return actor;
namespace Dali
{
-
class Actor;
class Image;
class Texture;
* @param[in] texture Texture to set.
* @return An actor with a renderer.
*/
-Actor CreateRenderableActor( Texture texture );
+Actor CreateRenderableActor(Texture texture);
/**
* @brief Creates a renderable-actor with a texture and custom shaders.
* @param[in] fragmentShader The fragment-shader.
* @return An actor with a renderer.
*/
-Actor CreateRenderableActor( Texture texture, const std::string& vertexShader, const std::string& fragmentShader );
+Actor CreateRenderableActor(Texture texture, const std::string& vertexShader, const std::string& fragmentShader);
} // namespace Dali
*/
#include "test-addon-manager.h"
+
#include <dali-test-suite-utils.h>
-#include <cstring>
#include <dlfcn.h>
+#include <cstring>
+
#ifndef ADDON_LIBS_PATH
#define ADDON_LIBS_PATH ""
#endif
{
namespace Test
{
-
std::vector<std::string> AddOnManager::EnumerateAddOns()
{
std::string listFileName(ADDON_LIBS_PATH);
// Read list of available test addons
tet_printf("Enumerating addons, file: %s\n", listFileName.c_str());
std::vector<std::string> addons{};
- auto* fin = fopen( listFileName.c_str(), "r" );
- char* lineBuf = new char[256];
- size_t n = 256;
- while( getline( &lineBuf, &n, fin ) > 0 )
+ auto* fin = fopen(listFileName.c_str(), "r");
+ char* lineBuf = new char[256];
+ size_t n = 256;
+ while(getline(&lineBuf, &n, fin) > 0)
{
tet_printf("Adding %s\n", lineBuf);
- addons.emplace_back( lineBuf );
+ addons.emplace_back(lineBuf);
}
fclose(fin);
- delete [] lineBuf;
+ delete[] lineBuf;
std::vector<std::string> retval{};
// Open addons
- for( auto& name : addons )
+ for(auto& name : addons)
{
std::string path(ADDON_LIBS_PATH);
path += "/";
path += name;
mAddOnCache.emplace_back();
- mAddOnCache.back().handle = dlopen( path.c_str(), RTLD_DEEPBIND|RTLD_LAZY );
- if( !mAddOnCache.back().handle )
+ mAddOnCache.back().handle = dlopen(path.c_str(), RTLD_DEEPBIND | RTLD_LAZY);
+ if(!mAddOnCache.back().handle)
{
mAddOnCache.back().valid = false;
- tet_printf( "Can't open addon lib: %s\n", path.c_str());
+ tet_printf("Can't open addon lib: %s\n", path.c_str());
continue;
}
// Here addon must self register
- if( !mAddOnCache.back().valid )
+ if(!mAddOnCache.back().valid)
{
puts("Addon invalid!");
}
else
{
- tet_printf( "Valid AddOn: %s\n", mAddOnCache.back().name.c_str() );
- retval.emplace_back( mAddOnCache.back().name );
+ tet_printf("Valid AddOn: %s\n", mAddOnCache.back().name.c_str());
+ retval.emplace_back(mAddOnCache.back().name);
}
}
*/
}
-void AddOnManager::RegisterAddOnDispatchTable( const AddOnDispatchTable* dispatchTable )
+void AddOnManager::RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable)
{
// Register the dispatch table
auto& entry = mAddOnCache.back();
- entry.name = dispatchTable->name;
- tet_printf( "Registering AddOn: %s\n", entry.name.c_str());
- entry.GetGlobalProc = dispatchTable->GetGlobalProc;
+ entry.name = dispatchTable->name;
+ tet_printf("Registering AddOn: %s\n", entry.name.c_str());
+ entry.GetGlobalProc = dispatchTable->GetGlobalProc;
entry.GetInstanceProc = dispatchTable->GetInstanceProc;
- entry.GetAddOnInfo = dispatchTable->GetAddOnInfo;
- entry.OnStart = dispatchTable->OnStart;
- entry.OnStop = dispatchTable->OnStop;
- entry.OnPause = dispatchTable->OnPause;
- entry.OnResume = dispatchTable->OnResume;
- entry.valid = true;
+ entry.GetAddOnInfo = dispatchTable->GetAddOnInfo;
+ entry.OnStart = dispatchTable->OnStart;
+ entry.OnStop = dispatchTable->OnStop;
+ entry.OnPause = dispatchTable->OnPause;
+ entry.OnResume = dispatchTable->OnResume;
+ entry.valid = true;
}
-bool AddOnManager::GetAddOnInfo(const std::string& name, AddOnInfo& info )
+bool AddOnManager::GetAddOnInfo(const std::string& name, AddOnInfo& info)
{
auto retval = false;
- std::find_if( mAddOnCache.begin(), mAddOnCache.end(),
- [&retval, name, &info]( AddOnCacheEntry& entry )
- {
+ std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &info](AddOnCacheEntry& entry) {
if(entry.name == name)
{
- entry.GetAddOnInfo( info );
+ entry.GetAddOnInfo(info);
retval = true;
return true;
}
return retval;
}
-std::vector<AddOnLibrary> AddOnManager::LoadAddOns( const std::vector<std::string>& addonNames )
+std::vector<AddOnLibrary> AddOnManager::LoadAddOns(const std::vector<std::string>& addonNames)
{
if(mAddOnCache.empty())
{
}
std::vector<AddOnLibrary> retval{};
- for( auto& name : addonNames)
+ for(auto& name : addonNames)
{
size_t index = 0;
- auto iter = std::find_if( mAddOnCache.begin(), mAddOnCache.end(),
- [&retval, name, &index]( AddOnCacheEntry& entry )
+ auto iter = std::find_if(mAddOnCache.begin(), mAddOnCache.end(), [&retval, name, &index](AddOnCacheEntry& entry) {
+ index++;
+ if(entry.name == name)
{
- index++;
- if(entry.name == name)
- {
- return true;
- }
- return false;
- });
- if( iter != mAddOnCache.end() )
+ return true;
+ }
+ return false;
+ });
+ if(iter != mAddOnCache.end())
{
- retval.emplace_back( *reinterpret_cast<void**>( &index ) );
+ retval.emplace_back(*reinterpret_cast<void**>(&index));
}
else
{
- retval.emplace_back( nullptr );
+ retval.emplace_back(nullptr);
}
}
return retval;
}
-void* AddOnManager::GetGlobalProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName )
+void* AddOnManager::GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
{
- auto index = *reinterpret_cast<const size_t*>( &addOnLibrary );
- return mAddOnCache[index-1].GetGlobalProc( procName );
+ auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
+ return mAddOnCache[index - 1].GetGlobalProc(procName);
}
-void* AddOnManager::GetInstanceProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName )
+void* AddOnManager::GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
{
- auto index = *reinterpret_cast<const size_t*>( &addOnLibrary );
- return mAddOnCache[index-1].GetInstanceProc( procName );
+ auto index = *reinterpret_cast<const size_t*>(&addOnLibrary);
+ return mAddOnCache[index - 1].GetInstanceProc(procName);
}
void AddOnManager::Start()
{
- for( auto& entry : mAddOnCache )
+ for(auto& entry : mAddOnCache)
{
if(entry.OnStart)
{
void AddOnManager::Resume()
{
- for( auto& entry : mAddOnCache )
+ for(auto& entry : mAddOnCache)
{
if(entry.OnResume)
{
void AddOnManager::Stop()
{
- for( auto& entry : mAddOnCache )
+ for(auto& entry : mAddOnCache)
{
if(entry.OnStop)
{
void AddOnManager::Pause()
{
- for( auto& entry : mAddOnCache )
+ for(auto& entry : mAddOnCache)
{
if(entry.OnPause)
{
}
}
-}
-}
-
+} // namespace Test
+} // namespace Dali
#include <dali/integration-api/addon-manager.h>
#include <dali/public-api/common/vector-wrapper.h>
+
#include <string>
namespace Dali
class AddOnManager : public Dali::Integration::AddOnManager
{
public:
-
/**
* @brief Constructor, initialised by the Adaptor
*/
/**
* @brief Destructor
*/
- virtual ~AddOnManager() = default;
+ ~AddOnManager() override = default;
std::vector<std::string> EnumerateAddOns() override;
- bool GetAddOnInfo(const std::string& name, AddOnInfo& info ) override;
+ bool GetAddOnInfo(const std::string& name, AddOnInfo& info) override;
- std::vector<AddOnLibrary> LoadAddOns( const std::vector<std::string>& addonNames ) override;
+ std::vector<AddOnLibrary> LoadAddOns(const std::vector<std::string>& addonNames) override;
- void* GetGlobalProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName ) override;
+ void* GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) override;
- void* GetInstanceProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName ) override;
+ void* GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) override;
- void RegisterAddOnDispatchTable( const AddOnDispatchTable* dispatchTable ) override;
+ void RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable) override;
void Start() override;
struct AddOnCacheEntry
{
std::string name{};
- AddOnInfo info{};
+ AddOnInfo info{};
// library handle
- void* handle {nullptr};
+ void* handle{nullptr};
// main function pointers
- void(*GetAddOnInfo)(AddOnInfo& ) = nullptr; ///< Returns AddOnInfo structure
- void*(*GetInstanceProc)( const char* ) = nullptr; ///< Returns pointer of instance function (member funtion)
- void*(*GetGlobalProc)( const char* ) = nullptr; ///< Returns pointer of global function (non-member function)
-
- void(*OnStart)() = nullptr;
- void(*OnResume)() = nullptr;
- void(*OnPause)() = nullptr;
- void(*OnStop)() = nullptr;
+ void (*GetAddOnInfo)(AddOnInfo&) = nullptr; ///< Returns AddOnInfo structure
+ void* (*GetInstanceProc)(const char*) = nullptr; ///< Returns pointer of instance function (member funtion)
+ void* (*GetGlobalProc)(const char*) = nullptr; ///< Returns pointer of global function (non-member function)
+
+ void (*OnStart)() = nullptr;
+ void (*OnResume)() = nullptr;
+ void (*OnPause)() = nullptr;
+ void (*OnStop)() = nullptr;
bool valid = false;
};
namespace Dali
{
-
bool TestApplication::mLoggingEnabled = true;
-TestApplication::TestApplication( uint32_t surfaceWidth,
- uint32_t surfaceHeight,
- uint32_t horizontalDpi,
- uint32_t verticalDpi,
- bool initialize,
- bool enablePartialUpdate )
-: mCore( NULL ),
- mSurfaceWidth( surfaceWidth ),
- mSurfaceHeight( surfaceHeight ),
- mFrame( 0u ),
- mDpi{ horizontalDpi, verticalDpi },
+TestApplication::TestApplication(uint32_t surfaceWidth,
+ uint32_t surfaceHeight,
+ uint32_t horizontalDpi,
+ uint32_t verticalDpi,
+ bool initialize,
+ bool enablePartialUpdate)
+: mCore(NULL),
+ mSurfaceWidth(surfaceWidth),
+ mSurfaceHeight(surfaceHeight),
+ mFrame(0u),
+ mDpi{horizontalDpi, verticalDpi},
mLastVSyncTime(0u),
mPartialUpdateEnabled(enablePartialUpdate)
{
- if( initialize )
+ if(initialize)
{
Initialize();
}
// We always need the first update!
mStatus.keepUpdating = Integration::KeepUpdating::STAGE_KEEP_RENDERING;
- mCore = Dali::Integration::Core::New( mRenderController,
- mPlatformAbstraction,
- mGlAbstraction,
- mGlSyncAbstraction,
- mGlContextHelperAbstraction,
- Integration::RenderToFrameBuffer::FALSE,
- Integration::DepthBufferAvailable::TRUE,
- Integration::StencilBufferAvailable::TRUE,
- mPartialUpdateEnabled ? Integration::PartialUpdateAvailable::TRUE : Integration::PartialUpdateAvailable::FALSE );
+ mCore = Dali::Integration::Core::New(mRenderController,
+ mPlatformAbstraction,
+ mGlAbstraction,
+ mGlSyncAbstraction,
+ mGlContextHelperAbstraction,
+ Integration::RenderToFrameBuffer::FALSE,
+ Integration::DepthBufferAvailable::TRUE,
+ Integration::StencilBufferAvailable::TRUE,
+ mPartialUpdateEnabled ? Integration::PartialUpdateAvailable::TRUE : Integration::PartialUpdateAvailable::FALSE);
mCore->ContextCreated();
Dali::Integration::Log::InstallLogFunction(logFunction);
Dali::Integration::Trace::LogContextFunction logContextFunction(&TestApplication::LogContext);
- Dali::Integration::Trace::InstallLogContextFunction( logContextFunction );
+ Dali::Integration::Trace::InstallLogContextFunction(logContextFunction);
- Dali::Integration::Trace::LogContext( true, "Test" );
+ Dali::Integration::Trace::LogContext(true, "Test");
}
void TestApplication::CreateScene()
{
- mScene = Dali::Integration::Scene::New( Size( static_cast<float>( mSurfaceWidth ), static_cast<float>( mSurfaceHeight ) ) );
- mScene.SetDpi( Vector2( static_cast<float>( mDpi.x ), static_cast<float>( mDpi.y ) ) );
+ mScene = Dali::Integration::Scene::New(Size(static_cast<float>(mSurfaceWidth), static_cast<float>(mSurfaceHeight)));
+ mScene.SetDpi(Vector2(static_cast<float>(mDpi.x), static_cast<float>(mDpi.y)));
}
void TestApplication::InitializeCore()
delete mCore;
}
-void TestApplication::LogContext( bool start, const char* tag )
+void TestApplication::LogContext(bool start, const char* tag)
{
- if( start )
+ if(start)
{
fprintf(stderr, "INFO: Trace Start: %s\n", tag);
}
void TestApplication::LogMessage(Dali::Integration::Log::DebugPriority level, std::string& message)
{
- if( mLoggingEnabled )
+ if(mLoggingEnabled)
{
switch(level)
{
mCore->ProcessEvents();
}
-void TestApplication::DoUpdate( uint32_t intervalMilliseconds, const char* location )
+void TestApplication::DoUpdate(uint32_t intervalMilliseconds, const char* location)
{
- if( GetUpdateStatus() == 0 &&
- mRenderStatus.NeedsUpdate() == false &&
- ! GetRenderController().WasCalled(TestRenderController::RequestUpdateFunc) )
+ if(GetUpdateStatus() == 0 &&
+ mRenderStatus.NeedsUpdate() == false &&
+ !GetRenderController().WasCalled(TestRenderController::RequestUpdateFunc))
{
- fprintf(stderr, "WARNING - Update not required :%s\n", location==NULL?"NULL":location);
+ fprintf(stderr, "WARNING - Update not required :%s\n", location == NULL ? "NULL" : location);
}
- uint32_t nextVSyncTime = mLastVSyncTime + intervalMilliseconds;
- float elapsedSeconds = static_cast<float>( intervalMilliseconds ) * 0.001f;
+ uint32_t nextVSyncTime = mLastVSyncTime + intervalMilliseconds;
+ float elapsedSeconds = static_cast<float>(intervalMilliseconds) * 0.001f;
- mCore->Update( elapsedSeconds, mLastVSyncTime, nextVSyncTime, mStatus, false, false );
+ mCore->Update(elapsedSeconds, mLastVSyncTime, nextVSyncTime, mStatus, false, false);
GetRenderController().Initialize();
mLastVSyncTime = nextVSyncTime;
}
-bool TestApplication::Render( uint32_t intervalMilliseconds, const char* location )
+bool TestApplication::Render(uint32_t intervalMilliseconds, const char* location)
{
- DoUpdate( intervalMilliseconds, location );
+ DoUpdate(intervalMilliseconds, location);
// Reset the status
- mRenderStatus.SetNeedsUpdate( false );
- mRenderStatus.SetNeedsPostRender( false );
+ mRenderStatus.SetNeedsUpdate(false);
+ mRenderStatus.SetNeedsPostRender(false);
- mCore->PreRender( mRenderStatus, false /*do not force clear*/, false /*do not skip rendering*/ );
- mCore->RenderScene( mRenderStatus, mScene, true /*render the off-screen buffers*/ );
- mCore->RenderScene( mRenderStatus, mScene, false /*render the surface*/ );
- mCore->PostRender( false /*do not skip rendering*/ );
+ mCore->PreRender(mRenderStatus, false /*do not force clear*/, false /*do not skip rendering*/);
+ mCore->RenderScene(mRenderStatus, mScene, true /*render the off-screen buffers*/);
+ mCore->RenderScene(mRenderStatus, mScene, false /*render the surface*/);
+ mCore->PostRender(false /*do not skip rendering*/);
mFrame++;
{
DoUpdate(intervalMilliseconds, location);
- mCore->PreRender(mRenderStatus, false /*do not force clear*/, false /*do not skip rendering*/ );
+ mCore->PreRender(mRenderStatus, false /*do not force clear*/, false /*do not skip rendering*/);
mCore->PreRender(mScene, damagedRects);
return mStatus.KeepUpdating() || mRenderStatus.NeedsUpdate();
return mStatus.KeepUpdating();
}
-bool TestApplication::UpdateOnly( uint32_t intervalMilliseconds )
+bool TestApplication::UpdateOnly(uint32_t intervalMilliseconds)
{
- DoUpdate( intervalMilliseconds );
+ DoUpdate(intervalMilliseconds);
return mStatus.KeepUpdating();
}
return mRenderStatus.NeedsPostRender();
}
-bool TestApplication::RenderOnly( )
+bool TestApplication::RenderOnly()
{
// Update Time values
- mCore->PreRender( mRenderStatus, false /*do not force clear*/, false /*do not skip rendering*/ );
- mCore->RenderScene( mRenderStatus, mScene, true /*render the off-screen buffers*/ );
- mCore->RenderScene( mRenderStatus, mScene, false /*render the surface*/ );
- mCore->PostRender( false /*do not skip rendering*/ );
+ mCore->PreRender(mRenderStatus, false /*do not force clear*/, false /*do not skip rendering*/);
+ mCore->RenderScene(mRenderStatus, mScene, true /*render the off-screen buffers*/);
+ mCore->RenderScene(mRenderStatus, mScene, false /*render the surface*/);
+ mCore->PostRender(false /*do not skip rendering*/);
mFrame++;
mCore->ContextCreated();
}
-uint32_t TestApplication::Wait( uint32_t durationToWait )
+uint32_t TestApplication::Wait(uint32_t durationToWait)
{
int time = 0;
- for(uint32_t i = 0; i <= ( durationToWait / RENDER_FRAME_INTERVAL); i++)
+ for(uint32_t i = 0; i <= (durationToWait / RENDER_FRAME_INTERVAL); i++)
{
SendNotification();
Render(RENDER_FRAME_INTERVAL);
return time;
}
-} // Namespace dali
+} // namespace Dali
*/
// INTERNAL INCLUDES
+#include <dali/integration-api/resource-policies.h>
+#include <dali/integration-api/scene.h>
+#include <dali/integration-api/trace.h>
+#include <dali/public-api/common/dali-common.h>
#include <test-platform-abstraction.h>
-#include "test-gl-sync-abstraction.h"
+
#include "test-gl-abstraction.h"
#include "test-gl-context-helper-abstraction.h"
+#include "test-gl-sync-abstraction.h"
#include "test-render-controller.h"
-#include <dali/public-api/common/dali-common.h>
-#include <dali/integration-api/resource-policies.h>
-#include <dali/integration-api/trace.h>
-#include <dali/integration-api/scene.h>
namespace Dali
{
-
class DALI_CORE_API TestApplication : public ConnectionTracker
{
public:
-
// Default values derived from H2 device.
- static const uint32_t DEFAULT_SURFACE_WIDTH = 480;
+ static const uint32_t DEFAULT_SURFACE_WIDTH = 480;
static const uint32_t DEFAULT_SURFACE_HEIGHT = 800;
static constexpr uint32_t DEFAULT_HORIZONTAL_DPI = 220;
static const uint32_t RENDER_FRAME_INTERVAL = 16;
- TestApplication( uint32_t surfaceWidth = DEFAULT_SURFACE_WIDTH,
- uint32_t surfaceHeight = DEFAULT_SURFACE_HEIGHT,
- uint32_t horizontalDpi = DEFAULT_HORIZONTAL_DPI,
- uint32_t verticalDpi = DEFAULT_VERTICAL_DPI,
- bool initialize = true,
- bool enablePartialUpdate = false );
+ TestApplication(uint32_t surfaceWidth = DEFAULT_SURFACE_WIDTH,
+ uint32_t surfaceHeight = DEFAULT_SURFACE_HEIGHT,
+ uint32_t horizontalDpi = DEFAULT_HORIZONTAL_DPI,
+ uint32_t verticalDpi = DEFAULT_VERTICAL_DPI,
+ bool initialize = true,
+ bool enablePartialUpdate = false);
void Initialize();
void CreateCore();
void CreateScene();
void InitializeCore();
- virtual ~TestApplication();
- static void LogMessage( Dali::Integration::Log::DebugPriority level, std::string& message );
- static void LogContext( bool start, const char* tag );
- Dali::Integration::Core& GetCore();
- TestPlatformAbstraction& GetPlatform();
- TestRenderController& GetRenderController();
- TestGlAbstraction& GetGlAbstraction();
- TestGlSyncAbstraction& GetGlSyncAbstraction();
+ ~TestApplication() override;
+ static void LogMessage(Dali::Integration::Log::DebugPriority level, std::string& message);
+ static void LogContext(bool start, const char* tag);
+ Dali::Integration::Core& GetCore();
+ TestPlatformAbstraction& GetPlatform();
+ TestRenderController& GetRenderController();
+ TestGlAbstraction& GetGlAbstraction();
+ TestGlSyncAbstraction& GetGlSyncAbstraction();
TestGlContextHelperAbstraction& GetGlContextHelperAbstraction();
- void ProcessEvent(const Integration::Event& event);
- void SendNotification();
- bool Render( uint32_t intervalMilliseconds = DEFAULT_RENDER_INTERVAL, const char* location=NULL );
- bool PreRenderWithPartialUpdate(uint32_t intervalMilliseconds, const char* location, std::vector<Rect<int>>& damagedRects);
- bool RenderWithPartialUpdate(std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect);
- uint32_t GetUpdateStatus();
- bool UpdateOnly( uint32_t intervalMilliseconds = DEFAULT_RENDER_INTERVAL );
- bool RenderOnly( );
- void ResetContext();
- bool GetRenderNeedsUpdate();
- bool GetRenderNeedsPostRender();
- uint32_t Wait( uint32_t durationToWait );
- static void EnableLogging( bool enabled )
+ void ProcessEvent(const Integration::Event& event);
+ void SendNotification();
+ bool Render(uint32_t intervalMilliseconds = DEFAULT_RENDER_INTERVAL, const char* location = NULL);
+ bool PreRenderWithPartialUpdate(uint32_t intervalMilliseconds, const char* location, std::vector<Rect<int>>& damagedRects);
+ bool RenderWithPartialUpdate(std::vector<Rect<int>>& damagedRects, Rect<int>& clippingRect);
+ uint32_t GetUpdateStatus();
+ bool UpdateOnly(uint32_t intervalMilliseconds = DEFAULT_RENDER_INTERVAL);
+ bool RenderOnly();
+ void ResetContext();
+ bool GetRenderNeedsUpdate();
+ bool GetRenderNeedsPostRender();
+ uint32_t Wait(uint32_t durationToWait);
+ static void EnableLogging(bool enabled)
{
mLoggingEnabled = enabled;
}
}
private:
- void DoUpdate( uint32_t intervalMilliseconds, const char* location=NULL );
+ void DoUpdate(uint32_t intervalMilliseconds, const char* location = NULL);
protected:
- TestPlatformAbstraction mPlatformAbstraction;
- TestRenderController mRenderController;
- TestGlAbstraction mGlAbstraction;
- TestGlSyncAbstraction mGlSyncAbstraction;
+ TestPlatformAbstraction mPlatformAbstraction;
+ TestRenderController mRenderController;
+ TestGlAbstraction mGlAbstraction;
+ TestGlSyncAbstraction mGlSyncAbstraction;
TestGlContextHelperAbstraction mGlContextHelperAbstraction;
Integration::UpdateStatus mStatus;
Integration::RenderStatus mRenderStatus;
- Integration::Core* mCore;
+ Integration::Core* mCore;
Dali::Integration::Scene mScene;
uint32_t mSurfaceWidth;
uint32_t mSurfaceHeight;
uint32_t mFrame;
- struct { uint32_t x; uint32_t y; } mDpi;
- uint32_t mLastVSyncTime;
- bool mPartialUpdateEnabled;
+ struct
+ {
+ uint32_t x;
+ uint32_t y;
+ } mDpi;
+ uint32_t mLastVSyncTime;
+ bool mPartialUpdateEnabled;
static bool mLoggingEnabled;
};
-} // Dali
+} // namespace Dali
#endif // DALI_TEST_APPLICATION_H
#define DALI_TEST_COMPARE_TYPES_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
using namespace Dali;
-
-template <typename Type>
+template<typename Type>
inline bool CompareType(Type value1, Type value2, float epsilon)
{
return value1 == value2;
* @param[in] epsilon difference threshold
* @returns true if difference is smaller than epsilon threshold, false otherwise
*/
-template <>
+template<>
inline bool CompareType<float>(float value1, float value2, float epsilon)
{
return fabsf(value1 - value2) < epsilon;
* @param[in] epsilon difference threshold
* @returns true if difference is smaller than epsilon threshold, false otherwise
*/
-template <>
+template<>
inline bool CompareType<Vector2>(Vector2 vector1, Vector2 vector2, float epsilon)
{
- return fabsf(vector1.x - vector2.x)<epsilon && fabsf(vector1.y - vector2.y)<epsilon;
+ return fabsf(vector1.x - vector2.x) < epsilon && fabsf(vector1.y - vector2.y) < epsilon;
}
/**
* @param[in] epsilon difference threshold
* @returns true if difference is smaller than epsilon threshold, false otherwise
*/
-template <>
+template<>
inline bool CompareType<Vector3>(Vector3 vector1, Vector3 vector2, float epsilon)
{
- return fabsf(vector1.x - vector2.x)<epsilon &&
- fabsf(vector1.y - vector2.y)<epsilon &&
- fabsf(vector1.z - vector2.z)<epsilon;
+ return fabsf(vector1.x - vector2.x) < epsilon &&
+ fabsf(vector1.y - vector2.y) < epsilon &&
+ fabsf(vector1.z - vector2.z) < epsilon;
}
-
/**
* A helper for fuzzy-comparing Vector4 objects
* @param[in] vector1 the first object
* @param[in] epsilon difference threshold
* @returns true if difference is smaller than epsilon threshold, false otherwise
*/
-template <>
+template<>
inline bool CompareType<Vector4>(Vector4 vector1, Vector4 vector2, float epsilon)
{
- return fabsf(vector1.x - vector2.x)<epsilon &&
- fabsf(vector1.y - vector2.y)<epsilon &&
- fabsf(vector1.z - vector2.z)<epsilon &&
- fabsf(vector1.w - vector2.w)<epsilon;
+ return fabsf(vector1.x - vector2.x) < epsilon &&
+ fabsf(vector1.y - vector2.y) < epsilon &&
+ fabsf(vector1.z - vector2.z) < epsilon &&
+ fabsf(vector1.w - vector2.w) < epsilon;
}
-template <>
+template<>
inline bool CompareType<Quaternion>(Quaternion q1, Quaternion q2, float epsilon)
{
Quaternion q2N = -q2; // These quaternions represent the same rotation
return CompareType<Vector4>(q1.mVector, q2.mVector, epsilon) || CompareType<Vector4>(q1.mVector, q2N.mVector, epsilon);
}
-template <>
+template<>
inline bool CompareType<Radian>(Radian q1, Radian q2, float epsilon)
{
return CompareType<float>(q1.radian, q2.radian, epsilon);
}
-template <>
+template<>
inline bool CompareType<Degree>(Degree q1, Degree q2, float epsilon)
{
return CompareType<float>(q1.degree, q2.degree, epsilon);
}
-template <>
+template<>
inline bool CompareType<Extents>(Extents extents1, Extents extents2, float epsilon)
{
return (extents1.start == extents2.start) &&
(extents1.bottom == extents2.bottom);
}
-template <>
+template<>
inline bool CompareType<Property::Value>(Property::Value q1, Property::Value q2, float epsilon)
{
Property::Type type = q1.GetType();
- if( type != q2.GetType() )
+ if(type != q2.GetType())
{
return false;
}
bool a, b;
q1.Get(a);
q2.Get(b);
- result = a == b;
+ result = a == b;
break;
}
case Property::INTEGER:
int a, b;
q1.Get(a);
q2.Get(b);
- result = a == b;
+ result = a == b;
break;
}
case Property::FLOAT:
float a, b;
q1.Get(a);
q2.Get(b);
- result = CompareType<float>(a, b, epsilon);
+ result = CompareType<float>(a, b, epsilon);
break;
}
case Property::VECTOR2:
case Property::MAP:
{
//TODO: Implement this?
- DALI_ASSERT_ALWAYS( 0 && "Not implemented");
+ DALI_ASSERT_ALWAYS(0 && "Not implemented");
result = false;
break;
}
Extents a, b;
q1.Get(a);
q2.Get(b);
- result = CompareType<Extents>( a, b, epsilon );
+ result = CompareType<Extents>(a, b, epsilon);
break;
}
case Property::NONE:
return result;
}
-
-
#endif
using namespace Dali;
-std::vector< std::string > MasterCallStack;
-bool gOnRelayout = false;
+std::vector<std::string> MasterCallStack;
+bool gOnRelayout = false;
namespace Test
{
struct TestCustomActor;
}
-
TestCustomActor TestCustomActor::New()
{
Impl::TestCustomActor* impl = new Impl::TestCustomActor;
- TestCustomActor custom( *impl ); // takes ownership
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
TestCustomActor TestCustomActor::NewNegoSize()
{
- Impl::TestCustomActor* impl = new Impl::TestCustomActor( true );
- TestCustomActor custom( *impl ); // takes ownership
- custom.SetProperty( Dali::Actor::Property::NAME, "SizeNegotiationActor" );
+ Impl::TestCustomActor* impl = new Impl::TestCustomActor(true);
+ TestCustomActor custom(*impl); // takes ownership
+ custom.SetProperty(Dali::Actor::Property::NAME, "SizeNegotiationActor");
impl->Initialize();
return custom;
}
-TestCustomActor TestCustomActor::NewVariant1( Actor childToAdd )
+TestCustomActor TestCustomActor::NewVariant1(Actor childToAdd)
{
- Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant1( childToAdd );
- TestCustomActor custom( *impl ); // takes ownership
+ Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant1(childToAdd);
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
TestCustomActor TestCustomActor::NewVariant2()
{
Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant2();
- TestCustomActor custom( *impl ); // takes ownership
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
return custom;
}
-TestCustomActor TestCustomActor::NewVariant3( Actor childToAdd )
+TestCustomActor TestCustomActor::NewVariant3(Actor childToAdd)
{
- Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant3( childToAdd );
- TestCustomActor custom( *impl ); // takes ownership
+ Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant3(childToAdd);
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
TestCustomActor TestCustomActor::NewVariant4()
{
Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant4();
- TestCustomActor custom( *impl ); // takes ownership
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
TestCustomActor TestCustomActor::NewVariant5(Integration::Scene scene)
{
Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant5(scene);
- TestCustomActor custom( *impl ); // takes ownership
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
TestCustomActor TestCustomActor::NewVariant6(Integration::Scene scene)
{
Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant6(scene);
- TestCustomActor custom( *impl ); // takes ownership
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
return custom;
}
-TestCustomActor TestCustomActor::NewVariant7( const char* name )
+TestCustomActor TestCustomActor::NewVariant7(const char* name)
{
Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant7();
- TestCustomActor custom( *impl ); // takes ownership
+ TestCustomActor custom(*impl); // takes ownership
- impl->Initialize( name );
+ impl->Initialize(name);
return custom;
}
-TestCustomActor TestCustomActor::NewVariant8( Actor rival )
+TestCustomActor TestCustomActor::NewVariant8(Actor rival)
{
- Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant8( rival );
- TestCustomActor custom( *impl ); // takes ownership
+ Impl::TestCustomActor* impl = new Impl::TestCustomActorVariant8(rival);
+ TestCustomActor custom(*impl); // takes ownership
impl->Initialize();
return static_cast<Impl::TestCustomActor&>(GetImplementation());
}
-std::vector< std::string >& TestCustomActor::GetMethodsCalled()
+std::vector<std::string>& TestCustomActor::GetMethodsCalled()
{
return GetImpl().mMethodsCalled;
}
Vector3 TestCustomActor::GetNaturalSize()
{
- return Vector3( 0.0f, 0.0f, 0.0f );
+ return Vector3(0.0f, 0.0f, 0.0f);
}
-float TestCustomActor::GetHeightForWidth( float width )
+float TestCustomActor::GetHeightForWidth(float width)
{
return 0.0f;
}
-float TestCustomActor::GetWidthForHeight( float height )
+float TestCustomActor::GetWidthForHeight(float height)
{
return 0.0f;
}
-void TestCustomActor::OnRelayout( const Vector2& size, RelayoutContainer& container )
+void TestCustomActor::OnRelayout(const Vector2& size, RelayoutContainer& container)
{
}
-void TestCustomActor::OnLayoutNegotiated( float size, Dimension::Type dimension )
+void TestCustomActor::OnLayoutNegotiated(float size, Dimension::Type dimension)
{
}
-void TestCustomActor::OnCalculateRelayoutSize( Dimension::Type dimension )
+void TestCustomActor::OnCalculateRelayoutSize(Dimension::Type dimension)
{
}
GetImpl().TestRelayoutRequest();
}
-float TestCustomActor::TestGetHeightForWidthBase( float width )
+float TestCustomActor::TestGetHeightForWidthBase(float width)
{
- return GetImpl().TestGetHeightForWidthBase( width );
+ return GetImpl().TestGetHeightForWidthBase(width);
}
-float TestCustomActor::TestGetWidthForHeightBase( float height )
+float TestCustomActor::TestGetWidthForHeightBase(float height)
{
- return GetImpl().TestGetWidthForHeightBase( height );
+ return GetImpl().TestGetWidthForHeightBase(height);
}
-float TestCustomActor::TestCalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
+float TestCustomActor::TestCalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension)
{
- return GetImpl().TestCalculateChildSizeBase( child, dimension );
+ return GetImpl().TestCalculateChildSizeBase(child, dimension);
}
-bool TestCustomActor::TestRelayoutDependentOnChildrenBase( Dimension::Type dimension )
+bool TestCustomActor::TestRelayoutDependentOnChildrenBase(Dimension::Type dimension)
{
- return GetImpl().TestRelayoutDependentOnChildrenBase( dimension );
+ return GetImpl().TestRelayoutDependentOnChildrenBase(dimension);
}
uint32_t TestCustomActor::GetDepth()
{
}
-TestCustomActor::TestCustomActor( Impl::TestCustomActor& impl )
-: CustomActor( impl )
+TestCustomActor::TestCustomActor(Impl::TestCustomActor& impl)
+: CustomActor(impl)
{
}
-TestCustomActor::TestCustomActor( Dali::Internal::CustomActor* internal )
-: CustomActor( internal )
+TestCustomActor::TestCustomActor(Dali::Internal::CustomActor* internal)
+: CustomActor(internal)
{
}
-TestCustomActor TestCustomActor::DownCast( BaseHandle handle )
+TestCustomActor TestCustomActor::DownCast(BaseHandle handle)
{
TestCustomActor actor;
- CustomActor custom = Dali::CustomActor::DownCast(handle);
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
Test::Impl::TestCustomActor* impl = dynamic_cast<Test::Impl::TestCustomActor*>(&customImpl);
- if( impl )
+ if(impl)
{
actor = TestCustomActor(customImpl.GetOwner());
}
namespace Impl
{
-
TestCustomActor::TestCustomActor()
-: CustomActorImpl( ActorFlags( DISABLE_SIZE_NEGOTIATION ) ),
- mDaliProperty( Property::INVALID_INDEX ),
- mSizeSet( Vector3::ZERO ),
- mTargetSize( Vector3::ZERO ),
- mNego( false ),
+: CustomActorImpl(ActorFlags(DISABLE_SIZE_NEGOTIATION)),
+ mDaliProperty(Property::INVALID_INDEX),
+ mSizeSet(Vector3::ZERO),
+ mTargetSize(Vector3::ZERO),
+ mNego(false),
mDepth(0u),
- develProp6( 10.0f )
+ develProp6(10.0f)
{
}
TestCustomActor::TestCustomActor(bool nego)
-: CustomActorImpl( ActorFlags() ),
- mDaliProperty( Property::INVALID_INDEX ),
- mSizeSet( Vector3::ZERO ),
- mTargetSize( Vector3::ZERO ),
- mNego( nego ),
- develProp6( 10.0f )
+: CustomActorImpl(ActorFlags()),
+ mDaliProperty(Property::INVALID_INDEX),
+ mSizeSet(Vector3::ZERO),
+ mTargetSize(Vector3::ZERO),
+ mNego(nego),
+ develProp6(10.0f)
{
}
/**
{
}
-void TestCustomActor::Initialize( const char* name )
+void TestCustomActor::Initialize(const char* name)
{
- mDaliProperty = Self().RegisterProperty( "Dali", std::string("no"), Property::READ_WRITE);
+ mDaliProperty = Self().RegisterProperty("Dali", std::string("no"), Property::READ_WRITE);
- OnInitialize( name );
+ OnInitialize(name);
}
-void TestCustomActor::OnInitialize( const char* name ) {}
+void TestCustomActor::OnInitialize(const char* name)
+{
+}
/**
* Resets the call stack
*/
void TestCustomActor::ResetCallStack()
{
- mSizeSet = Vector3();
+ mSizeSet = Vector3();
mTargetSize = Vector3();
mMethodsCalled.clear();
}
-void TestCustomActor::AddToCallStacks( const char* method )
+void TestCustomActor::AddToCallStacks(const char* method)
{
- mMethodsCalled.push_back( method );
+ mMethodsCalled.push_back(method);
// Combine Actor name with method string
- std::string nameAndMethod( Self().GetProperty< std::string >( Dali::Actor::Property::NAME ) );
- if ( 0 == nameAndMethod.size() )
+ std::string nameAndMethod(Self().GetProperty<std::string>(Dali::Actor::Property::NAME));
+ if(0 == nameAndMethod.size())
{
nameAndMethod = "Unknown: ";
}
}
nameAndMethod += method;
- MasterCallStack.push_back( nameAndMethod );
+ MasterCallStack.push_back(nameAndMethod);
}
// From CustomActorImpl
-void TestCustomActor::OnSceneConnection( int depth )
+void TestCustomActor::OnSceneConnection(int depth)
{
AddToCallStacks("OnSceneConnection");
mDepth = depth;
{
AddToCallStacks("OnChildRemove");
}
-void TestCustomActor::OnPropertySet( Property::Index index, const Property::Value& propertyValue )
+void TestCustomActor::OnPropertySet(Property::Index index, const Property::Value& propertyValue)
{
AddToCallStacks("OnPropertySet");
}
}
Vector3 TestCustomActor::GetNaturalSize()
{
- return Vector3( 0.0f, 0.0f, 0.0f );
+ return Vector3(0.0f, 0.0f, 0.0f);
}
-float TestCustomActor::GetHeightForWidth( float width )
+float TestCustomActor::GetHeightForWidth(float width)
{
return 0.0f;
}
-float TestCustomActor::GetWidthForHeight( float height )
+float TestCustomActor::GetWidthForHeight(float height)
{
return 0.0f;
}
-void TestCustomActor::OnRelayout( const Vector2& size, RelayoutContainer& container )
+void TestCustomActor::OnRelayout(const Vector2& size, RelayoutContainer& container)
{
gOnRelayout = true;
}
-void TestCustomActor::OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+void TestCustomActor::OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
{
}
-void TestCustomActor::OnCalculateRelayoutSize( Dimension::Type dimension )
+void TestCustomActor::OnCalculateRelayoutSize(Dimension::Type dimension)
{
}
-float TestCustomActor::CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+float TestCustomActor::CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension)
{
return 0.0f;
}
-void TestCustomActor::OnLayoutNegotiated( float size, Dimension::Type dimension )
+void TestCustomActor::OnLayoutNegotiated(float size, Dimension::Type dimension)
{
}
-bool TestCustomActor::RelayoutDependentOnChildren( Dimension::Type dimension )
+bool TestCustomActor::RelayoutDependentOnChildren(Dimension::Type dimension)
{
return false;
}
RelayoutRequest();
}
-float TestCustomActor::TestGetHeightForWidthBase( float width )
+float TestCustomActor::TestGetHeightForWidthBase(float width)
{
- return GetHeightForWidthBase( width );
+ return GetHeightForWidthBase(width);
}
-float TestCustomActor::TestGetWidthForHeightBase( float height )
+float TestCustomActor::TestGetWidthForHeightBase(float height)
{
- return GetWidthForHeightBase( height );
+ return GetWidthForHeightBase(height);
}
-float TestCustomActor::TestCalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
+float TestCustomActor::TestCalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension)
{
- return CalculateChildSizeBase( child, dimension );
+ return CalculateChildSizeBase(child, dimension);
}
-bool TestCustomActor::TestRelayoutDependentOnChildrenBase( Dimension::Type dimension )
+bool TestCustomActor::TestRelayoutDependentOnChildrenBase(Dimension::Type dimension)
{
- return RelayoutDependentOnChildrenBase( dimension );
+ return RelayoutDependentOnChildrenBase(dimension);
}
-void TestCustomActor::SetProperty( BaseObject* object, Property::Index index, const Property::Value& value )
+void TestCustomActor::SetProperty(BaseObject* object, Property::Index index, const Property::Value& value)
{
- Test::TestCustomActor actor = Test::TestCustomActor::DownCast( Dali::BaseHandle( object ) );
+ Test::TestCustomActor actor = Test::TestCustomActor::DownCast(Dali::BaseHandle(object));
- if ( actor )
+ if(actor)
{
TestCustomActor& actorImpl = GetImpl(actor);
switch(index)
}
}
-Property::Value TestCustomActor::GetProperty( BaseObject* object, Property::Index index )
+Property::Value TestCustomActor::GetProperty(BaseObject* object, Property::Index index)
{
- Test::TestCustomActor actor = Test::TestCustomActor::DownCast( Dali::BaseHandle( object ) );
+ Test::TestCustomActor actor = Test::TestCustomActor::DownCast(Dali::BaseHandle(object));
- if ( actor )
+ if(actor)
{
TestCustomActor& actorImpl = GetImpl(actor);
switch(index)
return Property::Value();
}
-
BaseHandle CreateActor()
{
return Test::TestCustomActor::New();
}
-DALI_TYPE_REGISTRATION_BEGIN( Test::TestCustomActor, Dali::CustomActor, CreateActor );
+DALI_TYPE_REGISTRATION_BEGIN(Test::TestCustomActor, Dali::CustomActor, CreateActor);
-DALI_PROPERTY_REGISTRATION( Test, TestCustomActor, "testProperty1", FLOAT, TEST_PROPERTY1)
-DALI_PROPERTY_REGISTRATION( Test, TestCustomActor, "testProperty2", VECTOR4, TEST_PROPERTY2)
-DALI_DEVEL_PROPERTY_REGISTRATION( Test, TestCustomActor, "develTestProperty3", VECTOR4, DEVEL_TEST_PROPERTY3)
-DALI_DEVEL_PROPERTY_REGISTRATION( Test, TestCustomActor, "develTestProperty4", INTEGER, DEVEL_TEST_PROPERTY4)
-DALI_DEVEL_PROPERTY_REGISTRATION( Test, TestCustomActor, "develTestProperty5", FLOAT, DEVEL_TEST_PROPERTY5)
-DALI_DEVEL_PROPERTY_REGISTRATION_READ_ONLY( Test, TestCustomActor, "develTestProperty6", FLOAT, DEVEL_TEST_PROPERTY6)
+DALI_PROPERTY_REGISTRATION(Test, TestCustomActor, "testProperty1", FLOAT, TEST_PROPERTY1)
+DALI_PROPERTY_REGISTRATION(Test, TestCustomActor, "testProperty2", VECTOR4, TEST_PROPERTY2)
+DALI_DEVEL_PROPERTY_REGISTRATION(Test, TestCustomActor, "develTestProperty3", VECTOR4, DEVEL_TEST_PROPERTY3)
+DALI_DEVEL_PROPERTY_REGISTRATION(Test, TestCustomActor, "develTestProperty4", INTEGER, DEVEL_TEST_PROPERTY4)
+DALI_DEVEL_PROPERTY_REGISTRATION(Test, TestCustomActor, "develTestProperty5", FLOAT, DEVEL_TEST_PROPERTY5)
+DALI_DEVEL_PROPERTY_REGISTRATION_READ_ONLY(Test, TestCustomActor, "develTestProperty6", FLOAT, DEVEL_TEST_PROPERTY6)
DALI_TYPE_REGISTRATION_END()
-} // Impl
-} // Test namespace
+} // namespace Impl
+} // namespace Test
*
*/
-#include <dali/public-api/dali-core.h>
#include <dali/devel-api/object/property-helper-devel.h>
#include <dali/integration-api/scene.h>
+#include <dali/public-api/dali-core.h>
-extern std::vector< std::string > MasterCallStack;
-extern bool gOnRelayout;
+extern std::vector<std::string> MasterCallStack;
+extern bool gOnRelayout;
namespace Test
{
enum PropertyRange
{
PROPERTY_START_INDEX = Dali::PROPERTY_REGISTRATION_START_INDEX,
- PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000
+ PROPERTY_END_INDEX = PROPERTY_START_INDEX + 1000
};
struct Property
TestCustomActor();
static TestCustomActor New();
static TestCustomActor NewNegoSize();
- static TestCustomActor NewVariant1( Actor childToAdd );
+ static TestCustomActor NewVariant1(Actor childToAdd);
static TestCustomActor NewVariant2();
- static TestCustomActor NewVariant3( Actor childToAdd );
+ static TestCustomActor NewVariant3(Actor childToAdd);
static TestCustomActor NewVariant4();
- static TestCustomActor NewVariant5( Dali::Integration::Scene scene );
- static TestCustomActor NewVariant6( Dali::Integration::Scene scene );
- static TestCustomActor NewVariant7( const char* name );
- static TestCustomActor NewVariant8( Actor rival );
- static TestCustomActor DownCast( Dali::BaseHandle handle );
+ static TestCustomActor NewVariant5(Dali::Integration::Scene scene);
+ static TestCustomActor NewVariant6(Dali::Integration::Scene scene);
+ static TestCustomActor NewVariant7(const char* name);
+ static TestCustomActor NewVariant8(Actor rival);
+ static TestCustomActor DownCast(Dali::BaseHandle handle);
virtual ~TestCustomActor();
Impl::TestCustomActor& GetImpl();
- TestCustomActor( TestCustomActor&& rhs ) = default;
- TestCustomActor& operator=( TestCustomActor&& rhs ) = default;
-
- std::vector< std::string >& GetMethodsCalled();
- void ResetCallStack();
- void SetDaliProperty(std::string s);
- Dali::Vector3 GetSize();
- Dali::Vector3 GetTargetSize();
- virtual Dali::Vector3 GetNaturalSize();
- virtual float GetHeightForWidth( float width );
- virtual float GetWidthForHeight( float height );
- virtual void OnRelayout( const Dali::Vector2& size, Dali::RelayoutContainer& container );
- virtual void OnLayoutNegotiated( float size, Dali::Dimension::Type dimension );
- virtual void OnCalculateRelayoutSize( Dali::Dimension::Type dimension );
- void TestRelayoutRequest();
- float TestGetHeightForWidthBase( float width );
- float TestGetWidthForHeightBase( float height );
- float TestCalculateChildSizeBase( const Dali::Actor& child, Dali::Dimension::Type dimension );
- bool TestRelayoutDependentOnChildrenBase( Dali::Dimension::Type dimension );
- uint32_t GetDepth();
+ TestCustomActor(TestCustomActor&& rhs) = default;
+ TestCustomActor& operator=(TestCustomActor&& rhs) = default;
+
+ std::vector<std::string>& GetMethodsCalled();
+ void ResetCallStack();
+ void SetDaliProperty(std::string s);
+ Dali::Vector3 GetSize();
+ Dali::Vector3 GetTargetSize();
+ virtual Dali::Vector3 GetNaturalSize();
+ virtual float GetHeightForWidth(float width);
+ virtual float GetWidthForHeight(float height);
+ virtual void OnRelayout(const Dali::Vector2& size, Dali::RelayoutContainer& container);
+ virtual void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension);
+ virtual void OnCalculateRelayoutSize(Dali::Dimension::Type dimension);
+ void TestRelayoutRequest();
+ float TestGetHeightForWidthBase(float width);
+ float TestGetWidthForHeightBase(float height);
+ float TestCalculateChildSizeBase(const Dali::Actor& child, Dali::Dimension::Type dimension);
+ bool TestRelayoutDependentOnChildrenBase(Dali::Dimension::Type dimension);
+ uint32_t GetDepth();
private:
- TestCustomActor( Impl::TestCustomActor& impl );
+ TestCustomActor(Impl::TestCustomActor& impl);
explicit TestCustomActor(Dali::Internal::CustomActor* internal);
};
-
namespace DevelTestCustomActor
{
namespace Property
{
enum Type
{
- TEST_PROPERTY1 = Test::TestCustomActor::Property::TEST_PROPERTY1,
- TEST_PROPERTY2 = Test::TestCustomActor::Property::TEST_PROPERTY2,
- DEVEL_TEST_PROPERTY3 = TEST_PROPERTY2+1,
- DEVEL_TEST_PROPERTY4 = TEST_PROPERTY2+2,
- DEVEL_TEST_PROPERTY5 = TEST_PROPERTY2+3,
- DEVEL_TEST_PROPERTY6 = TEST_PROPERTY2+4
+ TEST_PROPERTY1 = Test::TestCustomActor::Property::TEST_PROPERTY1,
+ TEST_PROPERTY2 = Test::TestCustomActor::Property::TEST_PROPERTY2,
+ DEVEL_TEST_PROPERTY3 = TEST_PROPERTY2 + 1,
+ DEVEL_TEST_PROPERTY4 = TEST_PROPERTY2 + 2,
+ DEVEL_TEST_PROPERTY5 = TEST_PROPERTY2 + 3,
+ DEVEL_TEST_PROPERTY6 = TEST_PROPERTY2 + 4
};
} // Namespace Property
} // Namespace DevelTestCustomActor
-
// TypeRegistry needs custom actor Implementations to have the same name (namespaces are ignored so we use one here)
namespace Impl
{
-
struct TestCustomActor : public Dali::CustomActorImpl
{
public:
TestCustomActor();
TestCustomActor(bool nego);
virtual ~TestCustomActor();
- void Initialize( const char* name = NULL );
- virtual void OnInitialize( const char* name );
- void ResetCallStack();
- void AddToCallStacks( const char* method );
- void OnSceneConnection( int depth ) override;
- void OnSceneDisconnection() override;
- void OnChildAdd(Dali::Actor& child) override;
- void OnChildRemove(Dali::Actor& child) override;
- void OnPropertySet( Dali::Property::Index index, const Dali::Property::Value& propertyValue ) override;
- void OnSizeSet(const Dali::Vector3& targetSize) override;
- void OnSizeAnimation(Dali::Animation& animation, const Dali::Vector3& targetSize) override;
- virtual void OnKeyInputFocusGained();
- virtual void OnKeyInputFocusLost();
- Dali::Vector3 GetNaturalSize() override;
- float GetHeightForWidth( float width ) override;
- float GetWidthForHeight( float height ) override;
- void OnRelayout( const Dali::Vector2& size, Dali::RelayoutContainer& container ) override;
- void OnSetResizePolicy( Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension ) override;
- void OnCalculateRelayoutSize( Dali::Dimension::Type dimension ) override;
- float CalculateChildSize( const Dali::Actor& child, Dali::Dimension::Type dimension ) override;
- void OnLayoutNegotiated( float size, Dali::Dimension::Type dimension ) override;
- bool RelayoutDependentOnChildren( Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS ) override;
- static void SetProperty( Dali::BaseObject* object, Dali::Property::Index index, const Dali::Property::Value& value );
- static Dali::Property::Value GetProperty( Dali::BaseObject* object, Dali::Property::Index index );
-
- void SetDaliProperty(std::string s);
- void TestRelayoutRequest();
- float TestGetHeightForWidthBase( float width );
- float TestGetWidthForHeightBase( float height );
- float TestCalculateChildSizeBase( const Dali::Actor& child, Dali::Dimension::Type dimension );
- bool TestRelayoutDependentOnChildrenBase( Dali::Dimension::Type dimension );
+ void Initialize(const char* name = NULL);
+ virtual void OnInitialize(const char* name);
+ void ResetCallStack();
+ void AddToCallStacks(const char* method);
+ void OnSceneConnection(int depth) override;
+ void OnSceneDisconnection() override;
+ void OnChildAdd(Dali::Actor& child) override;
+ void OnChildRemove(Dali::Actor& child) override;
+ void OnPropertySet(Dali::Property::Index index, const Dali::Property::Value& propertyValue) override;
+ void OnSizeSet(const Dali::Vector3& targetSize) override;
+ void OnSizeAnimation(Dali::Animation& animation, const Dali::Vector3& targetSize) override;
+ virtual void OnKeyInputFocusGained();
+ virtual void OnKeyInputFocusLost();
+ Dali::Vector3 GetNaturalSize() override;
+ float GetHeightForWidth(float width) override;
+ float GetWidthForHeight(float height) override;
+ void OnRelayout(const Dali::Vector2& size, Dali::RelayoutContainer& container) override;
+ void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) override;
+ void OnCalculateRelayoutSize(Dali::Dimension::Type dimension) override;
+ float CalculateChildSize(const Dali::Actor& child, Dali::Dimension::Type dimension) override;
+ void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) override;
+ bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) override;
+ static void SetProperty(Dali::BaseObject* object, Dali::Property::Index index, const Dali::Property::Value& value);
+ static Dali::Property::Value GetProperty(Dali::BaseObject* object, Dali::Property::Index index);
+
+ void SetDaliProperty(std::string s);
+ void TestRelayoutRequest();
+ float TestGetHeightForWidthBase(float width);
+ float TestGetWidthForHeightBase(float height);
+ float TestCalculateChildSizeBase(const Dali::Actor& child, Dali::Dimension::Type dimension);
+ bool TestRelayoutDependentOnChildrenBase(Dali::Dimension::Type dimension);
public:
- Dali::Property::Index mDaliProperty;
- std::vector< std::string > mMethodsCalled;
- Dali::Vector3 mSizeSet;
- Dali::Vector3 mTargetSize;
- bool mNego;
- uint32_t mDepth;
+ Dali::Property::Index mDaliProperty;
+ std::vector<std::string> mMethodsCalled;
+ Dali::Vector3 mSizeSet;
+ Dali::Vector3 mTargetSize;
+ bool mNego;
+ uint32_t mDepth;
float prop1;
Dali::Vector4 prop2;
float develProp6;
};
-inline TestCustomActor& GetImpl( Test::TestCustomActor& handle )
+inline TestCustomActor& GetImpl(Test::TestCustomActor& handle)
{
- DALI_ASSERT_ALWAYS( handle );
+ DALI_ASSERT_ALWAYS(handle);
Dali::RefObject& object = handle.GetImplementation();
- return static_cast<TestCustomActor&>( object );
+ return static_cast<TestCustomActor&>(object);
}
-inline const TestCustomActor& GetImpl( const Test::TestCustomActor& handle )
+inline const TestCustomActor& GetImpl(const Test::TestCustomActor& handle)
{
- DALI_ASSERT_ALWAYS( handle );
+ DALI_ASSERT_ALWAYS(handle);
const Dali::RefObject& object = handle.GetImplementation();
- return static_cast<const TestCustomActor&>( object );
+ return static_cast<const TestCustomActor&>(object);
}
-
/**
* Variant which adds a new child during OnSceneConnection
*/
/**
* Constructor
*/
- TestCustomActorVariant1( Dali::Actor childToAdd )
- : mChildToAdd( childToAdd )
+ TestCustomActorVariant1(Dali::Actor childToAdd)
+ : mChildToAdd(childToAdd)
{
}
// From CustomActorImpl
- void OnSceneConnection( int depth ) override
+ void OnSceneConnection(int depth) override
{
// Chain up first
- TestCustomActor::OnSceneConnection( depth );
+ TestCustomActor::OnSceneConnection(depth);
// Add the child
- Self().Add( mChildToAdd );
+ Self().Add(mChildToAdd);
}
Dali::Actor mChildToAdd;
}
// From CustomActorImpl
- virtual void OnSceneConnection( int depth )
+ virtual void OnSceneConnection(int depth)
{
// Chain up first
- TestCustomActor::OnSceneConnection( depth );
+ TestCustomActor::OnSceneConnection(depth);
// Remove all the children
- for( uint32_t i=0, num=Self().GetChildCount(); i<num; ++i )
+ for(uint32_t i = 0, num = Self().GetChildCount(); i < num; ++i)
{
- Self().Remove( Self().GetChildAt(0) );
+ Self().Remove(Self().GetChildAt(0));
}
}
};
/**
* Constructor
*/
- TestCustomActorVariant3( Dali::Actor childToAdd )
- : mChildToAdd( childToAdd )
+ TestCustomActorVariant3(Dali::Actor childToAdd)
+ : mChildToAdd(childToAdd)
{
}
TestCustomActor::OnSceneDisconnection();
// Add the child
- Self().Add( mChildToAdd );
+ Self().Add(mChildToAdd);
}
Dali::Actor mChildToAdd;
TestCustomActor::OnSceneDisconnection();
// Remove all the children
- for( uint32_t i=0, num=Self().GetChildCount(); i<num; ++i )
+ for(uint32_t i = 0, num = Self().GetChildCount(); i < num; ++i)
{
- Self().Remove( Self().GetChildAt(0) );
+ Self().Remove(Self().GetChildAt(0));
}
}
};
}
// From CustomActorImpl
- virtual void OnSceneConnection( int depth )
+ virtual void OnSceneConnection(int depth)
{
// Chain up first
- TestCustomActor::OnSceneConnection( depth );
+ TestCustomActor::OnSceneConnection(depth);
// Take parent off-stage
Dali::Actor parent = Self().GetParent();
- if ( parent )
+ if(parent)
{
- mScene.Remove( parent );
+ mScene.Remove(parent);
}
}
// Put parent on-stage
Dali::Actor parent = Self().GetParent();
- if ( parent )
+ if(parent)
{
- mScene.Add( parent );
+ mScene.Add(parent);
}
}
{
}
- virtual void OnInitialize( const char* name )
+ virtual void OnInitialize(const char* name)
{
// We need to do this early, before the OnChildAdd is recorded
- Self().SetProperty( Dali::Actor::Property::NAME, name );
+ Self().SetProperty(Dali::Actor::Property::NAME, name);
mContainer = Dali::Actor::New();
- mContainer.SetProperty( Dali::Actor::Property::NAME, "Container" );
- Self().Add( mContainer );
+ mContainer.SetProperty(Dali::Actor::Property::NAME, "Container");
+ Self().Add(mContainer);
}
// From CustomActorImpl
TestCustomActor::OnChildAdd(child);
// Reparent child
- if ( child != mContainer )
+ if(child != mContainer)
{
- mContainer.Add( child );
+ mContainer.Add(child);
}
}
/**
* Constructor
*/
- TestCustomActorVariant8( Dali::Actor rival )
- : mRivalContainer( rival )
+ TestCustomActorVariant8(Dali::Actor rival)
+ : mRivalContainer(rival)
{
}
// Chain up first
TestCustomActor::OnChildRemove(child);
- mRivalContainer.Remove( child ); // attempt to block reparenting to rival (should be a NOOP)
+ mRivalContainer.Remove(child); // attempt to block reparenting to rival (should be a NOOP)
}
Dali::Actor mRivalContainer;
class SimpleTestCustomActor : public Dali::CustomActorImpl
{
public:
-
/**
* Constructor
*/
SimpleTestCustomActor()
- : CustomActorImpl( ActorFlags( DISABLE_SIZE_NEGOTIATION ) )
+ : CustomActorImpl(ActorFlags(DISABLE_SIZE_NEGOTIATION))
{
}
}
// From CustomActorImpl
- void OnSceneConnection( int depth ) override
+ void OnSceneConnection(int depth) override
{
}
void OnSceneDisconnection() override
}
Dali::Vector3 GetNaturalSize() override
{
- return Dali::Vector3( 0.0f, 0.0f, 0.0f );
+ return Dali::Vector3(0.0f, 0.0f, 0.0f);
}
- float GetHeightForWidth( float width ) override
+ float GetHeightForWidth(float width) override
{
return 0.0f;
}
- float GetWidthForHeight( float height ) override
+ float GetWidthForHeight(float height) override
{
return 0.0f;
}
- void OnRelayout( const Dali::Vector2& size, Dali::RelayoutContainer& container ) override
+ void OnRelayout(const Dali::Vector2& size, Dali::RelayoutContainer& container) override
{
}
- void OnSetResizePolicy( Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension ) override
+ void OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) override
{
}
- void OnCalculateRelayoutSize( Dali::Dimension::Type dimension ) override
+ void OnCalculateRelayoutSize(Dali::Dimension::Type dimension) override
{
}
- float CalculateChildSize( const Dali::Actor& child, Dali::Dimension::Type dimension ) override
+ float CalculateChildSize(const Dali::Actor& child, Dali::Dimension::Type dimension) override
{
return 0.0f;
}
- void OnLayoutNegotiated( float size, Dali::Dimension::Type dimension ) override
+ void OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) override
{
}
- bool RelayoutDependentOnChildren( Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS ) override
+ bool RelayoutDependentOnChildren(Dali::Dimension::Type dimension = Dali::Dimension::ALL_DIMENSIONS) override
{
return false;
}
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace
{
-const uint32_t RENDER_FRAME_INTERVAL = 16; ///< Duration of each frame in ms. (at approx 60FPS)
+const uint32_t RENDER_FRAME_INTERVAL = 16; ///< Duration of each frame in ms. (at approx 60FPS)
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
+ Integration::Point point;
+ point.SetState(state);
point.SetDeviceId(4);
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-Integration::TouchEvent GenerateDoubleTouch( PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time )
+Integration::TouchEvent GenerateDoubleTouch(PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( stateA );
+ Integration::Point point;
+ point.SetState(stateA);
point.SetDeviceId(4);
- point.SetScreenPosition( screenPositionA );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
- point.SetScreenPosition( screenPositionB );
- point.SetState( stateB);
+ point.SetScreenPosition(screenPositionA);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
+ point.SetScreenPosition(screenPositionB);
+ point.SetState(stateB);
point.SetDeviceId(7);
- touchEvent.points.push_back( point );
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
return RENDER_FRAME_INTERVAL;
}
-void TestStartLongPress( TestApplication& application, float x, float y, uint32_t time )
+void TestStartLongPress(TestApplication& application, float x, float y, uint32_t time)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( x, y ), time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(x, y), time));
}
-void TestTriggerLongPress( TestApplication& application )
+void TestTriggerLongPress(TestApplication& application)
{
application.GetPlatform().TriggerTimer();
}
-void TestGenerateLongPress( TestApplication& application, float x, float y, uint32_t time )
+void TestGenerateLongPress(TestApplication& application, float x, float y, uint32_t time)
{
- TestStartLongPress( application, x, y, time );
- TestTriggerLongPress( application );
+ TestStartLongPress(application, x, y, time);
+ TestTriggerLongPress(application);
}
-void TestEndLongPress( TestApplication& application, float x, float y, uint32_t time )
+void TestEndLongPress(TestApplication& application, float x, float y, uint32_t time)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( x, y ), time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(x, y), time));
}
-void TestGeneratePinch( TestApplication& application)
+void TestGeneratePinch(TestApplication& application)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::MOTION, Vector2( 20.0f, 74.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 46.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 58.0f ), 190 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, Vector2( 20.0f, 55.0f ), PointState::UP, Vector2( 20.0f, 58.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::MOTION, Vector2(20.0f, 74.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 46.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 58.0f), 190));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, Vector2(20.0f, 55.0f), PointState::UP, Vector2(20.0f, 58.0f), 200));
}
-void TestStartPinch( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time )
+void TestStartPinch(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, a1, PointState::DOWN, b1, time ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 50 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 100 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 150 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, a1, PointState::DOWN, b1, time));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 50));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 100));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 150));
}
-void TestContinuePinch( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time )
+void TestContinuePinch(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a1, PointState::MOTION, b1, time ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a1, PointState::MOTION, b1, time + 50 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 100 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time +150 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a1, PointState::MOTION, b1, time));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a1, PointState::MOTION, b1, time + 50));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 100));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 150));
}
-void TestEndPinch( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time )
+void TestEndPinch(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a1, PointState::MOTION, b1, time ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, a2, PointState::UP, b2, time +50 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a1, PointState::MOTION, b1, time));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, a2, PointState::UP, b2, time + 50));
}
-void TestGenerateMiniPan( TestApplication& application)
+void TestGenerateMiniPan(TestApplication& application)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 250 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 251 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 40.0f ), 255 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 250));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 251));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 40.0f), 255));
}
-void TestStartPan( TestApplication& application, Vector2 start, Vector2 end, uint32_t& time )
+void TestStartPan(TestApplication& application, Vector2 start, Vector2 end, uint32_t& time)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, start, time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, start, time));
time += RENDER_FRAME_INTERVAL;
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, end, time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, end, time));
time += RENDER_FRAME_INTERVAL;
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, end, time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, end, time));
time += RENDER_FRAME_INTERVAL;
}
-void TestMovePan( TestApplication& application, Vector2 pos, uint32_t time )
+void TestMovePan(TestApplication& application, Vector2 pos, uint32_t time)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, pos, time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, pos, time));
}
-void TestEndPan( TestApplication& application, Vector2 pos, uint32_t time )
+void TestEndPan(TestApplication& application, Vector2 pos, uint32_t time)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, pos, time ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, pos, time));
}
-void TestGenerateTap( TestApplication& application, float x, float y, uint32_t time_down )
+void TestGenerateTap(TestApplication& application, float x, float y, uint32_t time_down)
{
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( x, y ), time_down ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( x, y ), time_down + 20 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(x, y), time_down));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(x, y), time_down + 20));
}
-void TestGenerateTwoPointTap( TestApplication& application, float x1, float y1, float x2, float y2, uint32_t time_down )
+void TestGenerateTwoPointTap(TestApplication& application, float x1, float y1, float x2, float y2, uint32_t time_down)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( x1, y1 ), PointState::DOWN, Vector2( x2, y2 ), time_down ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, Vector2( x1, y1 ), PointState::UP, Vector2( x2, y2 ), time_down + 20 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(x1, y1), PointState::DOWN, Vector2(x2, y2), time_down));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, Vector2(x1, y1), PointState::UP, Vector2(x2, y2), time_down + 20));
}
-void TestGenerateRotation( TestApplication& application )
+void TestGenerateRotation(TestApplication& application)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 25.0f, 95.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 30.0f, 100.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 35.0f, 105.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 40.0f, 110.0f ), 190 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), PointState::UP, Vector2( 45.0f, 115.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(25.0f, 95.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(30.0f, 100.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(35.0f, 105.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(40.0f, 110.0f), 190));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, Vector2(20.0f, 20.0f), PointState::UP, Vector2(45.0f, 115.0f), 200));
}
-void TestStartRotation( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time )
+void TestStartRotation(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, a1, PointState::DOWN, b1, time ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 50 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 100 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 150 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, a1, PointState::DOWN, b1, time));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 50));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 100));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 150));
}
-void TestContinueRotation( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time )
+void TestContinueRotation(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a1, PointState::MOTION, b1, time ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a1, PointState::MOTION, b1, time + 50 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time + 100 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a2, PointState::MOTION, b2, time +150 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a1, PointState::MOTION, b1, time));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a1, PointState::MOTION, b1, time + 50));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 100));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a2, PointState::MOTION, b2, time + 150));
}
-void TestEndRotation( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time )
+void TestEndRotation(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time)
{
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, a1, PointState::MOTION, b1, time ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, a2, PointState::UP, b2, time +50 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, a1, PointState::MOTION, b1, time));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, a2, PointState::UP, b2, time + 50));
}
} // namespace Dali
#define DALI_TEST_GESTURE_GENERATOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
/**
* Produces the initial touch of a long press
*/
-void TestStartLongPress( TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time = 450 );
+void TestStartLongPress(TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time = 450);
/**
* Triggers the timer to begin a long press gesture
*/
-void TestTriggerLongPress( TestApplication& application );
+void TestTriggerLongPress(TestApplication& application);
/**
* Produces the initial press and triggers the timer to begin a long press gesture
*/
-void TestGenerateLongPress( TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time = 450 );
+void TestGenerateLongPress(TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time = 450);
/**
* End a long press by lifting the touch
*/
-void TestEndLongPress( TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time = 450 );
+void TestEndLongPress(TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time = 450);
/**
* Produces a vertical pinch gesture between (20,20) and (20,90)
*/
-void TestGeneratePinch( TestApplication& application );
+void TestGeneratePinch(TestApplication& application);
/**
* Produces the gesture started event of a pinch, using 4 touches, 50ms apart, starting with 1, ending at 2
*/
-void TestStartPinch( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time );
+void TestStartPinch(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time);
/**
* Produces a gesture continuing event of a pinch, using 4 touches, 50ms apart, starting with 1, ending at 2
*/
-void TestContinuePinch( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time );
+void TestContinuePinch(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time);
/**
* Produces a gesture finished event of a pinch, using 2 touches, 50ms apart
*/
-void TestEndPinch( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time );
+void TestEndPinch(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time);
/**
* Produces a pan gesture from (20,20) to (20,40)
*/
-void TestGenerateMiniPan( TestApplication& application );
+void TestGenerateMiniPan(TestApplication& application);
/**
* Produces the start event of a pan gesture, assuming minimum distance moved between start and end is greater than 15
* in either direction or 11 in both (x&y). Time will be incremented using the standard frame interval per touch movement
*/
-void TestStartPan( TestApplication& application, Vector2 start, Vector2 end, uint32_t& time );
+void TestStartPan(TestApplication& application, Vector2 start, Vector2 end, uint32_t& time);
/**
* Continues a pan event by creating a single touch at pos.
* N.B This does not increment the time
*/
-void TestMovePan( TestApplication& application, Vector2 pos, uint32_t time = 400);
+void TestMovePan(TestApplication& application, Vector2 pos, uint32_t time = 400);
/**
* End a pan gesture at position pos
*/
-void TestEndPan( TestApplication& application, Vector2 pos, uint32_t time = 500);
+void TestEndPan(TestApplication& application, Vector2 pos, uint32_t time = 500);
/**
* Produces a single point tap gesture with a 20ms interval
*/
-void TestGenerateTap( TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time_down = 100 );
+void TestGenerateTap(TestApplication& application, float x = 20.0f, float y = 20.0f, uint32_t time_down = 100);
/**
* Produce a tap gesture with two touch points and a 20ms interval
*/
-void TestGenerateTwoPointTap( TestApplication& application, float x1, float y1, float x2, float y2, uint32_t time_down );
+void TestGenerateTwoPointTap(TestApplication& application, float x1, float y1, float x2, float y2, uint32_t time_down);
/**
* Produces a rotation gesture.
*/
-void TestGenerateRotation( TestApplication& application );
+void TestGenerateRotation(TestApplication& application);
/**
* Produces the gesture started event of a rotation, using 4 touches, 50ms apart, starting with 1, ending at 2
*/
-void TestStartRotation( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time );
+void TestStartRotation(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time);
/**
* Produces a gesture continuing event of a rotation, using 4 touches, 50ms apart, starting with 1, ending at 2
*/
-void TestContinueRotation( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time );
+void TestContinueRotation(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time);
/**
* Produces a gesture finished event of a rotation, using 2 touches, 50ms apart
*/
-void TestEndRotation( TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time );
+void TestEndRotation(TestApplication& application, Vector2 a1, Vector2 b1, Vector2 a2, Vector2 b2, uint32_t time);
} // namespace Dali
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
TestGlAbstraction::TestGlAbstraction()
{
Initialize();
}
-TestGlAbstraction::~TestGlAbstraction() {}
+TestGlAbstraction::~TestGlAbstraction()
+{
+}
void TestGlAbstraction::Initialize()
{
- mCurrentProgram = 0;
- mCompileStatus = GL_TRUE;
- mLinkStatus = GL_TRUE;
- mNumberOfActiveUniforms = 0;
- mGetAttribLocationResult = 0;
- mGetErrorResult = 0;
- mGetStringResult = NULL;
- mIsBufferResult = 0;
- mIsEnabledResult = 0;
- mIsFramebufferResult = 0;
- mIsProgramResult = 0;
- mIsRenderbufferResult = 0;
- mIsShaderResult = 0;
- mIsTextureResult = 0;
- mActiveTextureUnit = 0;
- mCheckFramebufferStatusResult = 0;
- mFramebufferStatus = 0;
- mFramebufferDepthAttached = 0;
- mFramebufferStencilAttached = 0;
+ mCurrentProgram = 0;
+ mCompileStatus = GL_TRUE;
+ mLinkStatus = GL_TRUE;
+ mNumberOfActiveUniforms = 0;
+ mGetAttribLocationResult = 0;
+ mGetErrorResult = 0;
+ mGetStringResult = NULL;
+ mIsBufferResult = 0;
+ mIsEnabledResult = 0;
+ mIsFramebufferResult = 0;
+ mIsProgramResult = 0;
+ mIsRenderbufferResult = 0;
+ mIsShaderResult = 0;
+ mIsTextureResult = 0;
+ mActiveTextureUnit = 0;
+ mCheckFramebufferStatusResult = 0;
+ mFramebufferStatus = 0;
+ mFramebufferDepthAttached = 0;
+ mFramebufferStencilAttached = 0;
mFramebufferColorAttachmentCount = 0;
- mFrameBufferColorStatus = 0;
- mNumBinaryFormats = 0;
- mBinaryFormats = 0;
- mProgramBinaryLength = 0;
+ mFrameBufferColorStatus = 0;
+ mNumBinaryFormats = 0;
+ mBinaryFormats = 0;
+ mProgramBinaryLength = 0;
mVertexAttribArrayChanged = false;
- mGetProgramBinaryCalled = false;
+ mGetProgramBinaryCalled = false;
mLastShaderCompiled = 0;
- mLastClearBitMask = 0;
- mLastClearColor = Color::TRANSPARENT;
- mClearCount = 0;
+ mLastClearBitMask = 0;
+ mLastClearColor = Color::TRANSPARENT;
+ mClearCount = 0;
mLastBlendEquationRgb = 0;
mLastBlendEquationAlpha = 0;
mLastBlendFuncDstRgb = 0;
mLastBlendFuncSrcAlpha = 0;
mLastBlendFuncDstAlpha = 0;
- mLastAutoTextureIdUsed = 0;
- mNumGeneratedTextures = 0;
- mLastShaderIdUsed = 0;
- mLastProgramIdUsed = 0;
- mLastUniformIdUsed = 0;
- mLastDepthMask = false;
+ mLastAutoTextureIdUsed = 0;
+ mNumGeneratedTextures = 0;
+ mLastShaderIdUsed = 0;
+ mLastProgramIdUsed = 0;
+ mLastUniformIdUsed = 0;
+ mLastDepthMask = false;
mUniforms.clear();
mProgramUniforms1i.clear();
mTexParamaterTrace.Reset();
mDrawTrace.Reset();
- for( unsigned int i=0; i<MAX_ATTRIBUTE_CACHE_SIZE; ++i )
+ for(unsigned int i = 0; i < MAX_ATTRIBUTE_CACHE_SIZE; ++i)
{
mVertexAttribArrayState[i] = false;
}
return true;
}
-bool TestGlAbstraction::TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const
+bool TestGlAbstraction::TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const
{
- return ( ( imageGlFormat == GL_RGB ) && ( textureGlFormat == GL_RGBA ) );
+ return ((imageGlFormat == GL_RGB) && (textureGlFormat == GL_RGBA));
}
-} // Namespace dali
+} // namespace Dali
bool BlendEnabled(const Dali::TraceCallStack& callStack)
{
std::stringstream out;
out << GL_BLEND;
- bool blendEnabled = callStack.FindMethodAndParams( "Enable", out.str() );
+ bool blendEnabled = callStack.FindMethodAndParams("Enable", out.str());
return blendEnabled;
}
{
std::stringstream out;
out << GL_BLEND;
- bool blendEnabled = callStack.FindMethodAndParams( "Disable", out.str() );
+ bool blendEnabled = callStack.FindMethodAndParams("Disable", out.str());
return blendEnabled;
}
-
*/
// EXTERNAL INCLUDES
-#include <sstream>
-#include <string>
-#include <cstring>
-#include <map>
#include <cstdio>
+#include <cstring>
#include <cstring> // for strcmp
+#include <map>
+#include <sstream>
+#include <string>
#include <typeinfo>
// INTERNAL INCLUDES
-#include <dali/public-api/dali-core.h>
#include <dali/devel-api/rendering/frame-buffer-devel.h>
#include <dali/integration-api/core.h>
#include <dali/integration-api/gl-abstraction.h>
#include <dali/integration-api/gl-defines.h>
-#include <test-trace-call-stack.h>
+#include <dali/public-api/dali-core.h>
#include <test-compare-types.h>
+#include <test-trace-call-stack.h>
namespace Dali
{
-
static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 64;
-static const char *mStdAttribs[MAX_ATTRIBUTE_CACHE_SIZE] =
-{
+static const char* mStdAttribs[MAX_ATTRIBUTE_CACHE_SIZE] =
+ {
"aPosition", // ATTRIB_POSITION
"aNormal", // ATTRIB_NORMAL
"aTexCoord", // ATTRIB_TEXCOORD
"aBoneIndices" // ATTRIB_BONE_INDICES
};
-class DALI_CORE_API TestGlAbstraction: public Dali::Integration::GlAbstraction
+class DALI_CORE_API TestGlAbstraction : public Dali::Integration::GlAbstraction
{
public:
TestGlAbstraction();
- ~TestGlAbstraction();
+ ~TestGlAbstraction() override;
void Initialize();
- void PreRender();
- void PostRender();
+ void PreRender() override;
+ void PostRender() override;
- bool IsSurfacelessContextSupported() const;
+ bool IsSurfacelessContextSupported() const override;
- bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const;
+ bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const override;
/* OpenGL ES 2.0 */
- inline void ActiveTexture( GLenum textureUnit )
+ inline void ActiveTexture(GLenum textureUnit) override
{
mActiveTextureUnit = textureUnit - GL_TEXTURE0;
}
return mActiveTextureUnit + GL_TEXTURE0;
}
- inline void AttachShader( GLuint program, GLuint shader )
+ inline void AttachShader(GLuint program, GLuint shader) override
{
std::stringstream out;
out << program << ", " << shader;
TraceCallStack::NamedParams namedParams;
namedParams["program"] = ToString(program);
- namedParams["shader"] = ToString(shader);
+ namedParams["shader"] = ToString(shader);
mShaderTrace.PushCall("AttachShader", out.str(), namedParams);
}
- inline void BindAttribLocation( GLuint program, GLuint index, const char* name )
+ inline void BindAttribLocation(GLuint program, GLuint index, const char* name) override
{
}
- inline void BindBuffer( GLenum target, GLuint buffer )
+ inline void BindBuffer(GLenum target, GLuint buffer) override
{
}
- inline void BindFramebuffer( GLenum target, GLuint framebuffer )
+ inline void BindFramebuffer(GLenum target, GLuint framebuffer) override
{
//Add 010 bit;
mFramebufferStatus |= 2;
}
- inline void BindRenderbuffer( GLenum target, GLuint renderbuffer )
+ inline void BindRenderbuffer(GLenum target, GLuint renderbuffer) override
{
}
* @param[in] activeTextureUnit The specific active texture unit.
* @return A vector containing the IDs that were bound.
*/
- inline const std::vector<GLuint>& GetBoundTextures( GLuint activeTextureUnit ) const
+ inline const std::vector<GLuint>& GetBoundTextures(GLuint activeTextureUnit) const
{
- return mActiveTextures[ activeTextureUnit - GL_TEXTURE0 ].mBoundTextures;
+ return mActiveTextures[activeTextureUnit - GL_TEXTURE0].mBoundTextures;
}
/**
{
mBoundTextures.clear();
- for( unsigned int i=0; i<MIN_TEXTURE_UNIT_LIMIT; ++i )
+ for(unsigned int i = 0; i < MIN_TEXTURE_UNIT_LIMIT; ++i)
{
- mActiveTextures[ i ].mBoundTextures.clear();
+ mActiveTextures[i].mBoundTextures.clear();
}
}
- inline void BindTexture( GLenum target, GLuint texture )
+ inline void BindTexture(GLenum target, GLuint texture) override
{
// Record the bound textures for future checks
- if( texture )
+ if(texture)
{
- mBoundTextures.push_back( texture );
+ mBoundTextures.push_back(texture);
- if( mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT )
+ if(mActiveTextureUnit < MIN_TEXTURE_UNIT_LIMIT)
{
- mActiveTextures[ mActiveTextureUnit ].mBoundTextures.push_back( texture );
+ mActiveTextures[mActiveTextureUnit].mBoundTextures.push_back(texture);
}
}
out << target << ", " << texture;
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
+ namedParams["target"] = ToString(target);
namedParams["texture"] = ToString(texture);
mTextureTrace.PushCall("BindTexture", out.str(), namedParams);
}
- inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+ inline void BlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
{
mLastBlendColor.r = red;
mLastBlendColor.g = green;
return mLastBlendColor;
}
- inline void BlendEquation( GLenum mode )
+ inline void BlendEquation(GLenum mode) override
{
mLastBlendEquationRgb = mode;
mLastBlendEquationAlpha = mode;
}
- inline void BlendEquationSeparate( GLenum modeRgb, GLenum modeAlpha )
+ inline void BlendEquationSeparate(GLenum modeRgb, GLenum modeAlpha) override
{
mLastBlendEquationRgb = modeRgb;
mLastBlendEquationAlpha = modeAlpha;
return mLastBlendEquationAlpha;
}
- inline void BlendFunc(GLenum sfactor, GLenum dfactor)
+ inline void BlendFunc(GLenum sfactor, GLenum dfactor) override
{
- mLastBlendFuncSrcRgb = sfactor;
- mLastBlendFuncDstRgb = dfactor;
+ mLastBlendFuncSrcRgb = sfactor;
+ mLastBlendFuncDstRgb = dfactor;
mLastBlendFuncSrcAlpha = sfactor;
mLastBlendFuncDstAlpha = dfactor;
}
- inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
+ inline void BlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) override
{
- mLastBlendFuncSrcRgb = srcRGB;
- mLastBlendFuncDstRgb = dstRGB;
+ mLastBlendFuncSrcRgb = srcRGB;
+ mLastBlendFuncDstRgb = dstRGB;
mLastBlendFuncSrcAlpha = srcAlpha;
mLastBlendFuncDstAlpha = dstAlpha;
}
return mLastBlendFuncDstAlpha;
}
- inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage)
+ inline void BufferData(GLenum target, GLsizeiptr size, const void* data, GLenum usage) override
{
- mBufferDataCalls.push_back(size);
+ mBufferDataCalls.push_back(size);
}
- inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data)
+ inline void BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void* data) override
{
- mBufferSubDataCalls.push_back(size);
+ mBufferSubDataCalls.push_back(size);
}
- inline GLenum CheckFramebufferStatus(GLenum target)
+ inline GLenum CheckFramebufferStatus(GLenum target) override
{
//If it has the three last bits set to 1 - 111, then the three minimum functions to create a
//Framebuffer texture have been called
- if( mFramebufferStatus == 7 )
+ if(mFramebufferStatus == 7)
{
return GL_FRAMEBUFFER_COMPLETE;
}
return mFramebufferStencilAttached;
}
- inline void Clear(GLbitfield mask)
+ inline void Clear(GLbitfield mask) override
{
mClearCount++;
mLastClearBitMask = mask;
}
- inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+ inline void ClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) override
{
mLastClearColor.r = red;
mLastClearColor.g = green;
return mLastClearColor;
}
- inline void ClearDepthf(GLclampf depth)
+ inline void ClearDepthf(GLclampf depth) override
{
}
- inline void ClearStencil(GLint s)
+ inline void ClearStencil(GLint s) override
{
std::stringstream out;
out << s;
TraceCallStack::NamedParams namedParams;
- namedParams["s"] = ToString( s );
+ namedParams["s"] = ToString(s);
- mStencilFunctionTrace.PushCall( "ClearStencil", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("ClearStencil", out.str(), namedParams);
}
- inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
+ inline void ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) override
{
- mColorMaskParams.red = red;
+ mColorMaskParams.red = red;
mColorMaskParams.green = green;
- mColorMaskParams.blue = blue;
+ mColorMaskParams.blue = blue;
mColorMaskParams.alpha = alpha;
}
- inline void CompileShader(GLuint shader)
+ inline void CompileShader(GLuint shader) override
{
std::stringstream out;
out << shader;
mShaderTrace.PushCall("CompileShader", out.str(), namedParams);
}
- inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
+ inline void CompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data) override
{
std::stringstream out;
- out << target<<", "<<level<<", "<<width << ", " << height;
+ out << target << ", " << level << ", " << width << ", " << height;
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
- namedParams["level"] = ToString(level);
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
namedParams["internalformat"] = ToString(internalformat);
- namedParams["width"] = ToString(width);
- namedParams["height"] = ToString(height);
- namedParams["border"] = ToString(border);
- namedParams["size"] = ToString(imageSize);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ namedParams["border"] = ToString(border);
+ namedParams["size"] = ToString(imageSize);
mTextureTrace.PushCall("CompressedTexImage2D", out.str(), namedParams);
}
- inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
+ inline void CompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data) override
{
std::stringstream out;
- out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
+ out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
- namedParams["level"] = ToString(level);
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
namedParams["xoffset"] = ToString(xoffset);
namedParams["yoffset"] = ToString(yoffset);
- namedParams["width"] = ToString(width);
- namedParams["height"] = ToString(height);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
mTextureTrace.PushCall("CompressedTexSubImage2D", out.str(), namedParams);
}
- inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+ inline void CopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) override
{
}
- inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ inline void CopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
{
}
- inline GLuint CreateProgram(void)
+ inline GLuint CreateProgram(void) override
{
mShaderTrace.PushCall("CreateProgram", "");
return mLastProgramIdUsed;
}
- inline GLuint CreateShader(GLenum type)
+ inline GLuint CreateShader(GLenum type) override
{
std::stringstream out;
out << type;
return ++mLastShaderIdUsed;
}
- inline void CullFace(GLenum mode)
+ inline void CullFace(GLenum mode) override
{
std::stringstream out;
out << mode;
mCullFaceTrace.PushCall("CullFace", out.str(), namedParams);
}
- inline void DeleteBuffers(GLsizei n, const GLuint* buffers)
+ inline void DeleteBuffers(GLsizei n, const GLuint* buffers) override
{
}
- inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
+ inline void DeleteFramebuffers(GLsizei n, const GLuint* framebuffers) override
{
}
- inline void DeleteProgram(GLuint program)
+ inline void DeleteProgram(GLuint program) override
{
std::stringstream out;
out << program;
mShaderTrace.PushCall("DeleteProgram", out.str(), namedParams);
}
- inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
+ inline void DeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers) override
{
}
- inline void DeleteShader(GLuint shader)
+ inline void DeleteShader(GLuint shader) override
{
std::stringstream out;
out << shader;
mShaderTrace.PushCall("DeleteShader", out.str(), namedParams);
}
- inline void DeleteTextures(GLsizei n, const GLuint* textures)
+ inline void DeleteTextures(GLsizei n, const GLuint* textures) override
{
std::stringstream out;
out << n << ", " << textures << " = [";
TraceCallStack::NamedParams namedParams;
- for(GLsizei i=0; i<n; i++)
+ for(GLsizei i = 0; i < n; i++)
{
out << textures[i] << ", ";
std::stringstream paramName;
- paramName<<"texture["<<i<<"]";
+ paramName << "texture[" << i << "]";
namedParams[paramName.str()] = ToString(textures[i]);
mDeletedTextureIds.push_back(textures[i]);
mNumGeneratedTextures--;
return mDeletedTextureIds.size() == 0;
}
- inline bool CheckTextureDeleted( GLuint textureId )
+ inline bool CheckTextureDeleted(GLuint textureId)
{
bool found = false;
- for(std::vector<GLuint>::iterator iter=mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
+ for(std::vector<GLuint>::iterator iter = mDeletedTextureIds.begin(); iter != mDeletedTextureIds.end(); ++iter)
{
if(*iter == textureId)
{
mDeletedTextureIds.clear();
}
- inline void DepthFunc(GLenum func)
+ inline void DepthFunc(GLenum func) override
{
std::stringstream out;
out << func;
mDepthFunctionTrace.PushCall("DepthFunc", out.str(), namedParams);
}
- inline void DepthMask(GLboolean flag)
+ inline void DepthMask(GLboolean flag) override
{
mLastDepthMask = flag;
}
return mLastDepthMask;
}
- inline void DepthRangef(GLclampf zNear, GLclampf zFar)
+ inline void DepthRangef(GLclampf zNear, GLclampf zFar) override
{
}
- inline void DetachShader(GLuint program, GLuint shader)
+ inline void DetachShader(GLuint program, GLuint shader) override
{
std::stringstream out;
out << program << ", " << shader;
TraceCallStack::NamedParams namedParams;
namedParams["program"] = ToString(program);
- namedParams["shader"] = ToString(shader);
+ namedParams["shader"] = ToString(shader);
mShaderTrace.PushCall("DetachShader", out.str(), namedParams);
}
- inline void Disable(GLenum cap)
+ inline void Disable(GLenum cap) override
{
std::stringstream out;
out << cap;
mEnableDisableTrace.PushCall("Disable", out.str(), namedParams);
}
- inline void DisableVertexAttribArray(GLuint index)
+ inline void DisableVertexAttribArray(GLuint index) override
{
- SetVertexAttribArray( index, false );
+ SetVertexAttribArray(index, false);
}
- inline void DrawArrays(GLenum mode, GLint first, GLsizei count)
+ inline void DrawArrays(GLenum mode, GLint first, GLsizei count) override
{
std::stringstream out;
out << mode << ", " << first << ", " << count;
TraceCallStack::NamedParams namedParams;
- namedParams["mode"] = ToString(mode);
+ namedParams["mode"] = ToString(mode);
namedParams["first"] = ToString(first);
namedParams["count"] = ToString(count);
mDrawTrace.PushCall("DrawArrays", out.str(), namedParams);
}
- inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices)
+ inline void DrawElements(GLenum mode, GLsizei count, GLenum type, const void* indices) override
{
std::stringstream out;
out << mode << ", " << count << ", " << type << ", indices";
TraceCallStack::NamedParams namedParams;
- namedParams["mode"] = ToString(mode);
+ namedParams["mode"] = ToString(mode);
namedParams["count"] = ToString(count);
- namedParams["type"] = ToString(type);
+ namedParams["type"] = ToString(type);
// Skip void pointers - are they of any use?
mDrawTrace.PushCall("DrawElements", out.str(), namedParams);
}
- inline void Enable(GLenum cap)
+ inline void Enable(GLenum cap) override
{
std::stringstream out;
out << cap;
mEnableDisableTrace.PushCall("Enable", out.str(), namedParams);
}
- inline void EnableVertexAttribArray(GLuint index)
+ inline void EnableVertexAttribArray(GLuint index) override
{
- SetVertexAttribArray( index, true);
+ SetVertexAttribArray(index, true);
}
- inline void Finish(void)
+ inline void Finish(void) override
{
}
- inline void Flush(void)
+ inline void Flush(void) override
{
}
- inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
+ inline void FramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) override
{
- if (attachment == GL_DEPTH_ATTACHMENT)
+ if(attachment == GL_DEPTH_ATTACHMENT)
{
mFramebufferDepthAttached = true;
}
- else if (attachment == GL_STENCIL_ATTACHMENT)
+ else if(attachment == GL_STENCIL_ATTACHMENT)
{
mFramebufferStencilAttached = true;
}
}
- inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
+ inline void FramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) override
{
//Add 100 bit;
mFramebufferStatus |= 4;
//We check 4 attachment colors
- if ((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
+ if((attachment >= GL_COLOR_ATTACHMENT0) && (attachment < GL_COLOR_ATTACHMENT0 + Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS))
{
uint8_t mask = 1 << (attachment - GL_COLOR_ATTACHMENT0);
- if ((mFrameBufferColorStatus & mask) == 0)
+ if((mFrameBufferColorStatus & mask) == 0)
{
mFrameBufferColorStatus |= mask;
++mFramebufferColorAttachmentCount;
}
}
- inline void FrontFace(GLenum mode)
+ inline void FrontFace(GLenum mode) override
{
}
- inline void GenBuffers(GLsizei n, GLuint* buffers)
+ inline void GenBuffers(GLsizei n, GLuint* buffers) override
{
// avoids an assert in GpuBuffers
*buffers = 1u;
}
- inline void GenerateMipmap(GLenum target)
+ inline void GenerateMipmap(GLenum target) override
{
std::stringstream out;
- out<<target;
+ out << target;
TraceCallStack::NamedParams namedParams;
namedParams["target"] = ToString(target);
mTextureTrace.PushCall("GenerateMipmap", out.str(), namedParams);
}
- inline void GenFramebuffers(GLsizei n, GLuint* framebuffers)
+ inline void GenFramebuffers(GLsizei n, GLuint* framebuffers) override
{
- for( int i = 0; i < n; i++ )
+ for(int i = 0; i < n; i++)
{
framebuffers[i] = i + 1;
}
mFramebufferStatus = 1;
}
- inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers)
+ inline void GenRenderbuffers(GLsizei n, GLuint* renderbuffers) override
{
- for( int i = 0; i < n; i++ )
+ for(int i = 0; i < n; i++)
{
renderbuffers[i] = i + 1;
}
* This method can be used by test cases, to manipulate the texture IDs generated by GenTextures.
* @param[in] ids A vector containing the next IDs to be generated
*/
- inline void SetNextTextureIds( const std::vector<GLuint>& ids )
+ inline void SetNextTextureIds(const std::vector<GLuint>& ids)
{
mNextTextureIds = ids;
}
return mNextTextureIds;
}
- inline void GenTextures(GLsizei count, GLuint* textures)
+ inline void GenTextures(GLsizei count, GLuint* textures) override
{
- for( int i=0; i<count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( !mNextTextureIds.empty() )
+ if(!mNextTextureIds.empty())
{
- *(textures+i) = mNextTextureIds[0];
- mNextTextureIds.erase( mNextTextureIds.begin() );
+ *(textures + i) = mNextTextureIds[0];
+ mNextTextureIds.erase(mNextTextureIds.begin());
}
else
{
- *(textures+i) = ++mLastAutoTextureIdUsed;
+ *(textures + i) = ++mLastAutoTextureIdUsed;
}
mNumGeneratedTextures++;
}
namedParams["count"] = ToString(count);
std::stringstream out;
- for(int i=0; i<count; i++)
+ for(int i = 0; i < count; i++)
{
out << textures[i];
- if(i<count-1)
+ if(i < count - 1)
{
out << ", ";
}
std::ostringstream oss;
- oss<<"indices["<<i<<"]";
+ oss << "indices[" << i << "]";
namedParams[oss.str()] = ToString(textures[i]);
}
{
return mLastAutoTextureIdUsed;
}
+
inline GLuint GetNumGeneratedTextures()
{
return mNumGeneratedTextures;
}
- inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+ inline void GetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
{
}
- inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
+ inline void GetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name) override
{
switch(index)
{
case 0:
*length = snprintf(name, bufsize, "sTexture");
- *type = GL_SAMPLER_2D;
- *size = 1;
+ *type = GL_SAMPLER_2D;
+ *size = 1;
break;
case 1:
*length = snprintf(name, bufsize, "sEffect");
- *type = GL_SAMPLER_2D;
- *size = 1;
+ *type = GL_SAMPLER_2D;
+ *size = 1;
break;
case 2:
*length = snprintf(name, bufsize, "sGloss");
- *type = GL_SAMPLER_2D;
- *size = 1;
+ *type = GL_SAMPLER_2D;
+ *size = 1;
break;
default:
break;
}
}
- inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
+ inline void GetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) override
{
}
- inline int GetAttribLocation(GLuint program, const char* name)
+ inline int GetAttribLocation(GLuint program, const char* name) override
{
std::string attribName(name);
- for( unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i )
+ for(unsigned int i = 0; i < ATTRIB_TYPE_LAST; ++i)
{
- if( mStdAttribs[i] == attribName )
+ if(mStdAttribs[i] == attribName)
{
return i;
}
return 0;
}
- inline void GetBooleanv(GLenum pname, GLboolean* params)
+ inline void GetBooleanv(GLenum pname, GLboolean* params) override
{
}
- inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
+ inline void GetBufferParameteriv(GLenum target, GLenum pname, GLint* params) override
{
}
- inline GLenum GetError(void)
+ inline GLenum GetError(void) override
{
return mGetErrorResult;
}
- inline void GetFloatv(GLenum pname, GLfloat* params)
+ inline void GetFloatv(GLenum pname, GLfloat* params) override
{
}
- inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
+ inline void GetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params) override
{
}
- inline void GetIntegerv(GLenum pname, GLint* params)
+ inline void GetIntegerv(GLenum pname, GLint* params) override
{
- switch( pname )
+ switch(pname)
{
case GL_MAX_TEXTURE_SIZE:
*params = 2048;
}
}
- inline void GetProgramiv(GLuint program, GLenum pname, GLint* params)
+ inline void GetProgramiv(GLuint program, GLenum pname, GLint* params) override
{
- switch( pname )
+ switch(pname)
{
case GL_LINK_STATUS:
*params = mLinkStatus;
}
}
- inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
+ inline void GetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog) override
{
}
- inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
+ inline void GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params) override
{
}
- inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params)
+ inline void GetShaderiv(GLuint shader, GLenum pname, GLint* params) override
{
- switch( pname ) {
+ switch(pname)
+ {
case GL_COMPILE_STATUS:
*params = mCompileStatus;
break;
}
}
- inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
+ inline void GetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog) override
{
}
- inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
+ inline void GetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) override
{
}
- inline const GLubyte* GetString(GLenum name)
+ inline const GLubyte* GetString(GLenum name) override
{
return mGetStringResult;
}
- inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
+ inline void GetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) override
{
}
- inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params)
+ inline void GetTexParameteriv(GLenum target, GLenum pname, GLint* params) override
{
}
- inline void GetUniformfv(GLuint program, GLint location, GLfloat* params)
+ inline void GetUniformfv(GLuint program, GLint location, GLfloat* params) override
{
}
- inline void GetUniformiv(GLuint program, GLint location, GLint* params)
+ inline void GetUniformiv(GLuint program, GLint location, GLint* params) override
{
}
- inline GLint GetUniformLocation(GLuint program, const char* name)
+ inline GLint GetUniformLocation(GLuint program, const char* name) override
{
ProgramUniformMap::iterator it = mUniforms.find(program);
- if( it == mUniforms.end() )
+ if(it == mUniforms.end())
{
// Not a valid program ID
mGetErrorResult = GL_INVALID_OPERATION;
return -1;
}
- UniformIDMap& uniformIDs = it->second;
- UniformIDMap::iterator it2 = uniformIDs.find( name );
- if( it2 == uniformIDs.end() )
+ UniformIDMap& uniformIDs = it->second;
+ UniformIDMap::iterator it2 = uniformIDs.find(name);
+ if(it2 == uniformIDs.end())
{
// Uniform not found, so add it...
uniformIDs[name] = ++mLastUniformIdUsed;
return it2->second;
}
- inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
+ inline void GetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params) override
{
}
- inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
+ inline void GetVertexAttribiv(GLuint index, GLenum pname, GLint* params) override
{
}
- inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
+ inline void GetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer) override
{
}
- inline void Hint(GLenum target, GLenum mode)
+ inline void Hint(GLenum target, GLenum mode) override
{
}
- inline GLboolean IsBuffer(GLuint buffer)
+ inline GLboolean IsBuffer(GLuint buffer) override
{
return mIsBufferResult;
}
- inline GLboolean IsEnabled(GLenum cap)
+ inline GLboolean IsEnabled(GLenum cap) override
{
return mIsEnabledResult;
}
- inline GLboolean IsFramebuffer(GLuint framebuffer)
+ inline GLboolean IsFramebuffer(GLuint framebuffer) override
{
return mIsFramebufferResult;
}
- inline GLboolean IsProgram(GLuint program)
+ inline GLboolean IsProgram(GLuint program) override
{
return mIsProgramResult;
}
- inline GLboolean IsRenderbuffer(GLuint renderbuffer)
+ inline GLboolean IsRenderbuffer(GLuint renderbuffer) override
{
return mIsRenderbufferResult;
}
- inline GLboolean IsShader(GLuint shader)
+ inline GLboolean IsShader(GLuint shader) override
{
return mIsShaderResult;
}
- inline GLboolean IsTexture(GLuint texture)
+ inline GLboolean IsTexture(GLuint texture) override
{
return mIsTextureResult;
}
- inline void LineWidth(GLfloat width)
+ inline void LineWidth(GLfloat width) override
{
}
- inline void LinkProgram(GLuint program)
+ inline void LinkProgram(GLuint program) override
{
std::stringstream out;
out << program;
namedParams["program"] = ToString(program);
mShaderTrace.PushCall("LinkProgram", out.str(), namedParams);
- mNumberOfActiveUniforms=3;
+ mNumberOfActiveUniforms = 3;
GetUniformLocation(program, "sTexture");
GetUniformLocation(program, "sEffect");
GetUniformLocation(program, "sGloss");
}
- inline void PixelStorei(GLenum pname, GLint param)
+ inline void PixelStorei(GLenum pname, GLint param) override
{
}
- inline void PolygonOffset(GLfloat factor, GLfloat units)
+ inline void PolygonOffset(GLfloat factor, GLfloat units) override
{
}
- inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels)
+ inline void ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void* pixels) override
{
}
- inline void ReleaseShaderCompiler(void)
+ inline void ReleaseShaderCompiler(void) override
{
}
- inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
+ inline void RenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) override
{
}
- inline void SampleCoverage(GLclampf value, GLboolean invert)
+ inline void SampleCoverage(GLclampf value, GLboolean invert) override
{
}
- inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
+ inline void Scissor(GLint x, GLint y, GLsizei width, GLsizei height) override
{
- mScissorParams.x = x;
- mScissorParams.y = y;
- mScissorParams.width = width;
+ mScissorParams.x = x;
+ mScissorParams.y = y;
+ mScissorParams.width = width;
mScissorParams.height = height;
std::stringstream out;
out << x << ", " << y << ", " << width << ", " << height;
TraceCallStack::NamedParams namedParams;
- namedParams["x"] = ToString( x );
- namedParams["y"] = ToString( y );
- namedParams["width"] = ToString( width );
- namedParams["height"] = ToString( height );
- mScissorTrace.PushCall( "Scissor", out.str(), namedParams );
+ namedParams["x"] = ToString(x);
+ namedParams["y"] = ToString(y);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ mScissorTrace.PushCall("Scissor", out.str(), namedParams);
}
- inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length)
+ inline void ShaderBinary(GLsizei n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLsizei length) override
{
}
- inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
+ inline void ShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length) override
{
std::string stringBuilder;
for(int i = 0; i < count; ++i)
stringBuilder += string[i];
}
mShaderSources[shader] = stringBuilder;
- mLastShaderCompiled = shader;
+ mLastShaderCompiled = shader;
}
- inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
+ inline void GetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source) override
{
- const std::string shaderSource = mShaderSources[shader];
- const int shaderSourceLength = static_cast<int>(shaderSource.length());
- if( shaderSourceLength < bufsize )
+ const std::string shaderSource = mShaderSources[shader];
+ const int shaderSourceLength = static_cast<int>(shaderSource.length());
+ if(shaderSourceLength < bufsize)
{
- strncpy( source, shaderSource.c_str(), shaderSourceLength );
+ strncpy(source, shaderSource.c_str(), shaderSourceLength);
*length = shaderSourceLength;
}
else
{
- *length = bufsize -1;
+ *length = bufsize - 1;
strncpy(source, shaderSource.c_str(), *length);
source[*length] = 0x0;
}
return mShaderSources[shader];
}
- inline void StencilFunc(GLenum func, GLint ref, GLuint mask)
+ inline void StencilFunc(GLenum func, GLint ref, GLuint mask) override
{
std::stringstream out;
out << func << ", " << ref << ", " << mask;
TraceCallStack::NamedParams namedParams;
- namedParams["func"] = ToString( func );
- namedParams["ref"] = ToString( ref );
- namedParams["mask"] = ToString( mask );
+ namedParams["func"] = ToString(func);
+ namedParams["ref"] = ToString(ref);
+ namedParams["mask"] = ToString(mask);
- mStencilFunctionTrace.PushCall( "StencilFunc", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("StencilFunc", out.str(), namedParams);
}
- inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
+ inline void StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) override
{
std::stringstream out;
out << face << ", " << func << ", " << ref << ", " << mask;
TraceCallStack::NamedParams namedParams;
- namedParams["face"] = ToString( face );
- namedParams["func"] = ToString( func );
- namedParams["ref"] = ToString( ref );
- namedParams["mask"] = ToString( mask );
+ namedParams["face"] = ToString(face);
+ namedParams["func"] = ToString(func);
+ namedParams["ref"] = ToString(ref);
+ namedParams["mask"] = ToString(mask);
- mStencilFunctionTrace.PushCall( "StencilFuncSeparate", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("StencilFuncSeparate", out.str(), namedParams);
}
- inline void StencilMask(GLuint mask)
+ inline void StencilMask(GLuint mask) override
{
std::stringstream out;
out << mask;
TraceCallStack::NamedParams namedParams;
- namedParams["mask"] = ToString( mask );
+ namedParams["mask"] = ToString(mask);
- mStencilFunctionTrace.PushCall( "StencilMask", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("StencilMask", out.str(), namedParams);
}
- inline void StencilMaskSeparate(GLenum face, GLuint mask)
+ inline void StencilMaskSeparate(GLenum face, GLuint mask) override
{
std::stringstream out;
out << face << ", " << mask;
TraceCallStack::NamedParams namedParams;
- namedParams["face"] = ToString( face );
- namedParams["mask"] = ToString( mask );
+ namedParams["face"] = ToString(face);
+ namedParams["mask"] = ToString(mask);
- mStencilFunctionTrace.PushCall( "StencilMaskSeparate", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("StencilMaskSeparate", out.str(), namedParams);
}
- inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
+ inline void StencilOp(GLenum fail, GLenum zfail, GLenum zpass) override
{
std::stringstream out;
out << fail << ", " << zfail << ", " << zpass;
TraceCallStack::NamedParams namedParams;
- namedParams["fail"] = ToString( fail );
- namedParams["zfail"] = ToString( zfail );
- namedParams["zpass"] = ToString( zpass );
+ namedParams["fail"] = ToString(fail);
+ namedParams["zfail"] = ToString(zfail);
+ namedParams["zpass"] = ToString(zpass);
- mStencilFunctionTrace.PushCall( "StencilOp", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("StencilOp", out.str(), namedParams);
}
- inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
+ inline void StencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) override
{
std::stringstream out;
out << face << ", " << fail << ", " << zfail << "," << zpass;
TraceCallStack::NamedParams namedParams;
- namedParams["face"] = ToString( face );
- namedParams["fail"] = ToString( fail );
- namedParams["zfail"] = ToString( zfail );
- namedParams["zpass"] = ToString( zpass );
+ namedParams["face"] = ToString(face);
+ namedParams["fail"] = ToString(fail);
+ namedParams["zfail"] = ToString(zfail);
+ namedParams["zpass"] = ToString(zpass);
- mStencilFunctionTrace.PushCall( "StencilOpSeparate", out.str(), namedParams );
+ mStencilFunctionTrace.PushCall("StencilOpSeparate", out.str(), namedParams);
}
- inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels)
+ inline void TexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels) override
{
std::stringstream out;
- out << target<<", "<<level<<", "<<width << ", " << height;
+ out << target << ", " << level << ", " << width << ", " << height;
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
- namedParams["level"] = ToString(level);
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
namedParams["internalformat"] = ToString(internalformat);
- namedParams["width"] = ToString(width);
- namedParams["height"] = ToString(height);
- namedParams["border"] = ToString(border);
- namedParams["format"] = ToString(format);
- namedParams["type"] = ToString(type);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
+ namedParams["border"] = ToString(border);
+ namedParams["format"] = ToString(format);
+ namedParams["type"] = ToString(type);
mTextureTrace.PushCall("TexImage2D", out.str(), namedParams);
}
- inline void TexParameterf(GLenum target, GLenum pname, GLfloat param)
+ inline void TexParameterf(GLenum target, GLenum pname, GLfloat param) override
{
std::stringstream out;
out << target << ", " << pname << ", " << param;
TraceCallStack::NamedParams namedParams;
namedParams["target"] = ToString(target);
- namedParams["pname"] = ToString(pname);
- namedParams["param"] = ToString(param);
+ namedParams["pname"] = ToString(pname);
+ namedParams["param"] = ToString(param);
mTexParamaterTrace.PushCall("TexParameterf", out.str(), namedParams);
}
- inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
+ inline void TexParameterfv(GLenum target, GLenum pname, const GLfloat* params) override
{
std::stringstream out;
out << target << ", " << pname << ", " << params[0];
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
- namedParams["pname"] = ToString(pname);
+ namedParams["target"] = ToString(target);
+ namedParams["pname"] = ToString(pname);
namedParams["params[0]"] = ToString(params[0]);
mTexParamaterTrace.PushCall("TexParameterfv", out.str(), namedParams);
}
- inline void TexParameteri(GLenum target, GLenum pname, GLint param)
+ inline void TexParameteri(GLenum target, GLenum pname, GLint param) override
{
std::stringstream out;
out << target << ", " << pname << ", " << param;
TraceCallStack::NamedParams namedParams;
namedParams["target"] = ToString(target);
- namedParams["pname"] = ToString(pname);
- namedParams["param"] = ToString(param);
+ namedParams["pname"] = ToString(pname);
+ namedParams["param"] = ToString(param);
mTexParamaterTrace.PushCall("TexParameteri", out.str(), namedParams);
}
- inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params)
+ inline void TexParameteriv(GLenum target, GLenum pname, const GLint* params) override
{
std::stringstream out;
out << target << ", " << pname << ", " << params[0];
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
- namedParams["pname"] = ToString(pname);
+ namedParams["target"] = ToString(target);
+ namedParams["pname"] = ToString(pname);
namedParams["params[0]"] = ToString(params[0]);
mTexParamaterTrace.PushCall("TexParameteriv", out.str(), namedParams);
}
- inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels)
+ inline void TexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels) override
{
std::stringstream out;
- out << target << ", "<<level <<", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
+ out << target << ", " << level << ", " << xoffset << ", " << yoffset << ", " << width << ", " << height;
TraceCallStack::NamedParams namedParams;
- namedParams["target"] = ToString(target);
- namedParams["level"] = ToString(level);
+ namedParams["target"] = ToString(target);
+ namedParams["level"] = ToString(level);
namedParams["xoffset"] = ToString(xoffset);
namedParams["yoffset"] = ToString(yoffset);
- namedParams["width"] = ToString(width);
- namedParams["height"] = ToString(height);
+ namedParams["width"] = ToString(width);
+ namedParams["height"] = ToString(height);
mTextureTrace.PushCall("TexSubImage2D", out.str(), namedParams);
}
- inline void Uniform1f(GLint location, GLfloat value )
+ inline void Uniform1f(GLint location, GLfloat value) override
{
- std::string params = ToString( value );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(value);
+ AddUniformCallToTraceStack(location, params);
- if( ! mProgramUniforms1f.SetUniformValue( mCurrentProgram, location, value ) )
+ if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, value))
{
mGetErrorResult = GL_INVALID_OPERATION;
}
}
- inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v)
+ inline void Uniform1fv(GLint location, GLsizei count, const GLfloat* v) override
{
std::string params;
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- params = params + ToString( v[i] ) + ",";
+ params = params + ToString(v[i]) + ",";
}
- AddUniformCallToTraceStack( location, params );
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniforms1f.SetUniformValue( mCurrentProgram, location, v[i] ) )
+ if(!mProgramUniforms1f.SetUniformValue(mCurrentProgram, location, v[i]))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void Uniform1i(GLint location, GLint x)
+ inline void Uniform1i(GLint location, GLint x) override
{
- std::string params = ToString( x );
+ std::string params = ToString(x);
- AddUniformCallToTraceStack( location, params );
+ AddUniformCallToTraceStack(location, params);
- if( ! mProgramUniforms1i.SetUniformValue( mCurrentProgram, location, x ) )
+ if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram, location, x))
{
mGetErrorResult = GL_INVALID_OPERATION;
}
}
- inline void Uniform1iv(GLint location, GLsizei count, const GLint* v)
+ inline void Uniform1iv(GLint location, GLsizei count, const GLint* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniforms1i.SetUniformValue( mCurrentProgram,
- location,
- v[i] ) )
+ if(!mProgramUniforms1i.SetUniformValue(mCurrentProgram,
+ location,
+ v[i]))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void Uniform2f(GLint location, GLfloat x, GLfloat y)
+ inline void Uniform2f(GLint location, GLfloat x, GLfloat y) override
{
- std::string params = ToString( x ) + "," + ToString( y );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(x) + "," + ToString(y);
+ AddUniformCallToTraceStack(location, params);
- if( ! mProgramUniforms2f.SetUniformValue( mCurrentProgram,
- location,
- Vector2( x, y ) ) )
+ if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
+ location,
+ Vector2(x, y)))
{
mGetErrorResult = GL_INVALID_OPERATION;
}
}
- inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v)
+ inline void Uniform2fv(GLint location, GLsizei count, const GLfloat* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniforms2f.SetUniformValue( mCurrentProgram,
- location,
- Vector2( v[2*i], v[2*i+1] ) ) )
+ if(!mProgramUniforms2f.SetUniformValue(mCurrentProgram,
+ location,
+ Vector2(v[2 * i], v[2 * i + 1])))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void Uniform2i(GLint location, GLint x, GLint y)
+ inline void Uniform2i(GLint location, GLint x, GLint y) override
{
- std::string params = ToString( x ) + "," + ToString( y );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(x) + "," + ToString(y);
+ AddUniformCallToTraceStack(location, params);
}
- inline void Uniform2iv(GLint location, GLsizei count, const GLint* v)
+ inline void Uniform2iv(GLint location, GLsizei count, const GLint* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
}
- inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
+ inline void Uniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z) override
{
- std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
+ AddUniformCallToTraceStack(location, params);
- if( ! mProgramUniforms3f.SetUniformValue( mCurrentProgram,
- location,
- Vector3( x, y, z ) ) )
+ if(!mProgramUniforms3f.SetUniformValue(mCurrentProgram,
+ location,
+ Vector3(x, y, z)))
{
mGetErrorResult = GL_INVALID_OPERATION;
}
}
- inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v)
+ inline void Uniform3fv(GLint location, GLsizei count, const GLfloat* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniforms3f.SetUniformValue(
- mCurrentProgram,
- location,
- Vector3( v[3*i], v[3*i+1], v[3*i+2] ) ) )
+ if(!mProgramUniforms3f.SetUniformValue(
+ mCurrentProgram,
+ location,
+ Vector3(v[3 * i], v[3 * i + 1], v[3 * i + 2])))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void Uniform3i(GLint location, GLint x, GLint y, GLint z)
+ inline void Uniform3i(GLint location, GLint x, GLint y, GLint z) override
{
- std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z);
+ AddUniformCallToTraceStack(location, params);
}
- inline void Uniform3iv(GLint location, GLsizei count, const GLint* v)
+ inline void Uniform3iv(GLint location, GLsizei count, const GLint* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
}
- inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ inline void Uniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
{
- std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z ) + "," + ToString( w );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
+ AddUniformCallToTraceStack(location, params);
- if( ! mProgramUniforms4f.SetUniformValue( mCurrentProgram,
- location,
- Vector4( x, y, z, w ) ) )
+ if(!mProgramUniforms4f.SetUniformValue(mCurrentProgram,
+ location,
+ Vector4(x, y, z, w)))
{
mGetErrorResult = GL_INVALID_OPERATION;
}
}
- inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v)
+ inline void Uniform4fv(GLint location, GLsizei count, const GLfloat* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniforms4f.SetUniformValue(
- mCurrentProgram,
- location,
- Vector4( v[4*i], v[4*i+1], v[4*i+2], v[4*i+3] ) ) )
+ if(!mProgramUniforms4f.SetUniformValue(
+ mCurrentProgram,
+ location,
+ Vector4(v[4 * i], v[4 * i + 1], v[4 * i + 2], v[4 * i + 3])))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
+ inline void Uniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) override
{
- std::string params = ToString( x ) + "," + ToString( y ) + "," + ToString( z ) + "," + ToString( w );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(x) + "," + ToString(y) + "," + ToString(z) + "," + ToString(w);
+ AddUniformCallToTraceStack(location, params);
}
- inline void Uniform4iv(GLint location, GLsizei count, const GLint* v)
+ inline void Uniform4iv(GLint location, GLsizei count, const GLint* v) override
{
- std::string params = ToString( v );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(v);
+ AddUniformCallToTraceStack(location, params);
}
- inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
- std::string params = ToString( value );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(value);
+ AddUniformCallToTraceStack(location, params);
}
- inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
- std::string params = ToString( value );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(value);
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniformsMat3.SetUniformValue(
- mCurrentProgram,
- location,
- Matrix3( value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8] ) ) )
+ if(!mProgramUniformsMat3.SetUniformValue(
+ mCurrentProgram,
+ location,
+ Matrix3(value[0], value[1], value[2], value[3], value[4], value[5], value[6], value[7], value[8])))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
- std::string params = ToString( value );
- AddUniformCallToTraceStack( location, params );
+ std::string params = ToString(value);
+ AddUniformCallToTraceStack(location, params);
- for( int i = 0; i < count; ++i )
+ for(int i = 0; i < count; ++i)
{
- if( ! mProgramUniformsMat4.SetUniformValue(
- mCurrentProgram,
- location,
- Matrix( value ) ) )
+ if(!mProgramUniformsMat4.SetUniformValue(
+ mCurrentProgram,
+ location,
+ Matrix(value)))
{
mGetErrorResult = GL_INVALID_OPERATION;
break;
}
}
- inline void UseProgram(GLuint program)
+ inline void UseProgram(GLuint program) override
{
mCurrentProgram = program;
}
- inline void ValidateProgram(GLuint program)
+ inline void ValidateProgram(GLuint program) override
{
}
- inline void VertexAttrib1f(GLuint indx, GLfloat x)
+ inline void VertexAttrib1f(GLuint indx, GLfloat x) override
{
}
- inline void VertexAttrib1fv(GLuint indx, const GLfloat* values)
+ inline void VertexAttrib1fv(GLuint indx, const GLfloat* values) override
{
}
- inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
+ inline void VertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) override
{
}
- inline void VertexAttrib2fv(GLuint indx, const GLfloat* values)
+ inline void VertexAttrib2fv(GLuint indx, const GLfloat* values) override
{
}
- inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
+ inline void VertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) override
{
}
- inline void VertexAttrib3fv(GLuint indx, const GLfloat* values)
+ inline void VertexAttrib3fv(GLuint indx, const GLfloat* values) override
{
}
- inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
+ inline void VertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) override
{
}
- inline void VertexAttrib4fv(GLuint indx, const GLfloat* values)
+ inline void VertexAttrib4fv(GLuint indx, const GLfloat* values) override
{
}
- inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
+ inline void VertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr) override
{
}
- inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
+ inline void Viewport(GLint x, GLint y, GLsizei width, GLsizei height) override
{
std::string commaString(", ");
- std::string params( std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height) );
+ std::string params(std::to_string(x) + commaString + std::to_string(y) + commaString + std::to_string(width) + commaString + std::to_string(height));
mViewportTrace.PushCall("Viewport", params);
}
/* OpenGL ES 3.0 */
- inline void ReadBuffer(GLenum mode)
+ inline void ReadBuffer(GLenum mode) override
{
}
- inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices)
+ inline void DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) override
{
}
- inline void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
+ inline void TexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid* pixels) override
{
}
- inline void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels)
+ inline void TexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) override
{
}
- inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+ inline void CopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) override
{
}
- inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data)
+ inline void CompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) override
{
}
- inline void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data)
+ inline void CompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) override
{
}
- inline void GenQueries(GLsizei n, GLuint* ids)
+ inline void GenQueries(GLsizei n, GLuint* ids) override
{
}
- inline void DeleteQueries(GLsizei n, const GLuint* ids)
+ inline void DeleteQueries(GLsizei n, const GLuint* ids) override
{
}
- inline GLboolean IsQuery(GLuint id)
+ inline GLboolean IsQuery(GLuint id) override
{
return false;
}
- inline void BeginQuery(GLenum target, GLuint id)
+ inline void BeginQuery(GLenum target, GLuint id) override
{
}
- inline void EndQuery(GLenum target)
+ inline void EndQuery(GLenum target) override
{
}
- inline void GetQueryiv(GLenum target, GLenum pname, GLint* params)
+ inline void GetQueryiv(GLenum target, GLenum pname, GLint* params) override
{
}
- inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
+ inline void GetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) override
{
}
- inline GLboolean UnmapBuffer(GLenum target)
+ inline GLboolean UnmapBuffer(GLenum target) override
{
return false;
}
- inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params)
+ inline void GetBufferPointerv(GLenum target, GLenum pname, GLvoid** params) override
{
}
- inline void DrawBuffers(GLsizei n, const GLenum* bufs)
+ inline void DrawBuffers(GLsizei n, const GLenum* bufs) override
{
}
- inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
}
- inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
}
- inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
}
- inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
}
- inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
}
- inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
+ inline void UniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) override
{
}
- inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
+ inline void BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) override
{
}
- inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
+ inline void RenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) override
{
}
- inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
+ inline void FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) override
{
}
- inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
+ inline GLvoid* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) override
{
return NULL;
}
- inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
+ inline void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) override
{
}
- inline void BindVertexArray(GLuint array)
+ inline void BindVertexArray(GLuint array) override
{
}
- inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays)
+ inline void DeleteVertexArrays(GLsizei n, const GLuint* arrays) override
{
}
- inline void GenVertexArrays(GLsizei n, GLuint* arrays)
+ inline void GenVertexArrays(GLsizei n, GLuint* arrays) override
{
}
- inline GLboolean IsVertexArray(GLuint array)
+ inline GLboolean IsVertexArray(GLuint array) override
{
return false;
}
- inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data)
+ inline void GetIntegeri_v(GLenum target, GLuint index, GLint* data) override
{
}
- inline void BeginTransformFeedback(GLenum primitiveMode)
+ inline void BeginTransformFeedback(GLenum primitiveMode) override
{
}
- inline void EndTransformFeedback(void)
+ inline void EndTransformFeedback(void) override
{
}
- inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
+ inline void BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) override
{
}
- inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer)
+ inline void BindBufferBase(GLenum target, GLuint index, GLuint buffer) override
{
}
- inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
+ inline void TransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) override
{
}
- inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
+ inline void GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) override
{
}
- inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
+ inline void VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) override
{
}
- inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
+ inline void GetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) override
{
}
- inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
+ inline void GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) override
{
}
- inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
+ inline void VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) override
{
}
- inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
+ inline void VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) override
{
}
- inline void VertexAttribI4iv(GLuint index, const GLint* v)
+ inline void VertexAttribI4iv(GLuint index, const GLint* v) override
{
}
- inline void VertexAttribI4uiv(GLuint index, const GLuint* v)
+ inline void VertexAttribI4uiv(GLuint index, const GLuint* v) override
{
}
- inline void GetUniformuiv(GLuint program, GLint location, GLuint* params)
+ inline void GetUniformuiv(GLuint program, GLint location, GLuint* params) override
{
}
- inline GLint GetFragDataLocation(GLuint program, const GLchar *name)
+ inline GLint GetFragDataLocation(GLuint program, const GLchar* name) override
{
return -1;
}
- inline void Uniform1ui(GLint location, GLuint v0)
+ inline void Uniform1ui(GLint location, GLuint v0) override
{
}
- inline void Uniform2ui(GLint location, GLuint v0, GLuint v1)
+ inline void Uniform2ui(GLint location, GLuint v0, GLuint v1) override
{
}
- inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
+ inline void Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) override
{
}
- inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+ inline void Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) override
{
}
- inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value)
+ inline void Uniform1uiv(GLint location, GLsizei count, const GLuint* value) override
{
}
- inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value)
+ inline void Uniform2uiv(GLint location, GLsizei count, const GLuint* value) override
{
}
- inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value)
+ inline void Uniform3uiv(GLint location, GLsizei count, const GLuint* value) override
{
}
- inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value)
+ inline void Uniform4uiv(GLint location, GLsizei count, const GLuint* value) override
{
}
- inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value)
+ inline void ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) override
{
}
- inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value)
+ inline void ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) override
{
}
- inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value)
+ inline void ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) override
{
}
- inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
+ inline void ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) override
{
}
- inline const GLubyte* GetStringi(GLenum name, GLuint index)
+ inline const GLubyte* GetStringi(GLenum name, GLuint index) override
{
return NULL;
}
- inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
+ inline void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) override
{
}
- inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices)
+ inline void GetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) override
{
}
- inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params)
+ inline void GetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) override
{
}
- inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName)
+ inline GLuint GetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) override
{
return GL_INVALID_INDEX;
}
- inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
+ inline void GetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) override
{
}
- inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
+ inline void GetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) override
{
}
- inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
+ inline void UniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) override
{
}
- inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount)
+ inline void DrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instanceCount) override
{
}
- inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount)
+ inline void DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei instanceCount) override
{
}
- inline GLsync FenceSync(GLenum condition, GLbitfield flags)
+ inline GLsync FenceSync(GLenum condition, GLbitfield flags) override
{
return NULL;
}
- inline GLboolean IsSync(GLsync sync)
+ inline GLboolean IsSync(GLsync sync) override
{
return false;
}
- inline void DeleteSync(GLsync sync)
+ inline void DeleteSync(GLsync sync) override
{
}
- inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+ inline GLenum ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
{
return 0;
}
- inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
+ inline void WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) override
{
}
- inline void GetInteger64v(GLenum pname, GLint64* params)
+ inline void GetInteger64v(GLenum pname, GLint64* params) override
{
}
- inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
+ inline void GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) override
{
}
- inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data)
+ inline void GetInteger64i_v(GLenum target, GLuint index, GLint64* data) override
{
}
- inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
+ inline void GetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params) override
{
}
- inline void GenSamplers(GLsizei count, GLuint* samplers)
+ inline void GenSamplers(GLsizei count, GLuint* samplers) override
{
}
- inline void DeleteSamplers(GLsizei count, const GLuint* samplers)
+ inline void DeleteSamplers(GLsizei count, const GLuint* samplers) override
{
}
- inline GLboolean IsSampler(GLuint sampler)
+ inline GLboolean IsSampler(GLuint sampler) override
{
return false;
}
- inline void BindSampler(GLuint unit, GLuint sampler)
+ inline void BindSampler(GLuint unit, GLuint sampler) override
{
}
- inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param)
+ inline void SamplerParameteri(GLuint sampler, GLenum pname, GLint param) override
{
}
- inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
+ inline void SamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) override
{
}
- inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
+ inline void SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) override
{
}
- inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
+ inline void SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) override
{
}
- inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
+ inline void GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) override
{
}
- inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
+ inline void GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) override
{
}
- inline void VertexAttribDivisor(GLuint index, GLuint divisor)
+ inline void VertexAttribDivisor(GLuint index, GLuint divisor) override
{
}
- inline void BindTransformFeedback(GLenum target, GLuint id)
+ inline void BindTransformFeedback(GLenum target, GLuint id) override
{
}
- inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
+ inline void DeleteTransformFeedbacks(GLsizei n, const GLuint* ids) override
{
}
- inline void GenTransformFeedbacks(GLsizei n, GLuint* ids)
+ inline void GenTransformFeedbacks(GLsizei n, GLuint* ids) override
{
}
- inline GLboolean IsTransformFeedback(GLuint id)
+ inline GLboolean IsTransformFeedback(GLuint id) override
{
return false;
}
- inline void PauseTransformFeedback(void)
+ inline void PauseTransformFeedback(void) override
{
}
- inline void ResumeTransformFeedback(void)
+ inline void ResumeTransformFeedback(void) override
{
}
- inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary)
+ inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
{
mGetProgramBinaryCalled = true;
}
- inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length)
+ inline void ProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid* binary, GLsizei length) override
{
}
- inline void ProgramParameteri(GLuint program, GLenum pname, GLint value)
+ inline void ProgramParameteri(GLuint program, GLenum pname, GLint value) override
{
}
- inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments)
+ inline void InvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) override
{
}
- inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height)
+ inline void InvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) override
{
}
- inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
+ inline void TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) override
{
}
- inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
+ inline void TexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) override
{
}
- inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
+ inline void GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) override
{
}
private:
-
- inline void AddUniformCallToTraceStack( GLint location, std::string& value )
- {
- std::string name = "<not found>";
- bool matched = false;
+ inline void AddUniformCallToTraceStack(GLint location, std::string& value)
+ {
+ std::string name = "<not found>";
+ bool matched = false;
UniformIDMap& map = mUniforms[mCurrentProgram];
- for (UniformIDMap::iterator it=map.begin(); it!=map.end(); ++it)
+ for(UniformIDMap::iterator it = map.begin(); it != map.end(); ++it)
{
- if( it->second == location )
+ if(it->second == location)
{
- name = it->first;
+ name = it->first;
matched = true;
break;
}
}
- if ( matched )
+ if(matched)
{
- mSetUniformTrace.PushCall( name, value );
+ mSetUniformTrace.PushCall(name, value);
}
}
-
public: // TEST FUNCTIONS
- inline void SetCompileStatus( GLuint value ) { mCompileStatus = value; }
- inline void SetLinkStatus( GLuint value ) { mLinkStatus = value; }
- inline void SetGetAttribLocationResult( int result) { mGetAttribLocationResult = result; }
- inline void SetGetErrorResult( GLenum result) { mGetErrorResult = result; }
- inline void SetGetStringResult( GLubyte* result) { mGetStringResult = result; }
- inline void SetIsBufferResult( GLboolean result) { mIsBufferResult = result; }
- inline void SetIsEnabledResult( GLboolean result) { mIsEnabledResult = result; }
- inline void SetIsFramebufferResult( GLboolean result) { mIsFramebufferResult = result; }
- inline void SetIsProgramResult( GLboolean result) { mIsProgramResult = result; }
- inline void SetIsRenderbufferResult( GLboolean result) { mIsRenderbufferResult = result; }
- inline void SetIsShaderResult( GLboolean result) { mIsShaderResult = result; }
- inline void SetIsTextureResult( GLboolean result) { mIsTextureResult = result; }
- inline void SetCheckFramebufferStatusResult( GLenum result) { mCheckFramebufferStatusResult = result; }
- inline void SetNumBinaryFormats( GLint numFormats ) { mNumBinaryFormats = numFormats; }
- inline void SetBinaryFormats( GLint binaryFormats ) { mBinaryFormats = binaryFormats; }
- inline void SetProgramBinaryLength( GLint length ) { mProgramBinaryLength = length; }
+ inline void SetCompileStatus(GLuint value)
+ {
+ mCompileStatus = value;
+ }
+ inline void SetLinkStatus(GLuint value)
+ {
+ mLinkStatus = value;
+ }
+ inline void SetGetAttribLocationResult(int result)
+ {
+ mGetAttribLocationResult = result;
+ }
+ inline void SetGetErrorResult(GLenum result)
+ {
+ mGetErrorResult = result;
+ }
+ inline void SetGetStringResult(GLubyte* result)
+ {
+ mGetStringResult = result;
+ }
+ inline void SetIsBufferResult(GLboolean result)
+ {
+ mIsBufferResult = result;
+ }
+ inline void SetIsEnabledResult(GLboolean result)
+ {
+ mIsEnabledResult = result;
+ }
+ inline void SetIsFramebufferResult(GLboolean result)
+ {
+ mIsFramebufferResult = result;
+ }
+ inline void SetIsProgramResult(GLboolean result)
+ {
+ mIsProgramResult = result;
+ }
+ inline void SetIsRenderbufferResult(GLboolean result)
+ {
+ mIsRenderbufferResult = result;
+ }
+ inline void SetIsShaderResult(GLboolean result)
+ {
+ mIsShaderResult = result;
+ }
+ inline void SetIsTextureResult(GLboolean result)
+ {
+ mIsTextureResult = result;
+ }
+ inline void SetCheckFramebufferStatusResult(GLenum result)
+ {
+ mCheckFramebufferStatusResult = result;
+ }
+ inline void SetNumBinaryFormats(GLint numFormats)
+ {
+ mNumBinaryFormats = numFormats;
+ }
+ inline void SetBinaryFormats(GLint binaryFormats)
+ {
+ mBinaryFormats = binaryFormats;
+ }
+ inline void SetProgramBinaryLength(GLint length)
+ {
+ mProgramBinaryLength = length;
+ }
inline bool GetVertexAttribArrayState(GLuint index)
{
- if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
+ if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
{
// out of range
return false;
}
- return mVertexAttribArrayState[ index ];
+ return mVertexAttribArrayState[index];
+ }
+ inline void ClearVertexAttribArrayChanged()
+ {
+ mVertexAttribArrayChanged = false;
+ }
+ inline bool GetVertexAttribArrayChanged()
+ {
+ return mVertexAttribArrayChanged;
}
- inline void ClearVertexAttribArrayChanged() { mVertexAttribArrayChanged = false; }
- inline bool GetVertexAttribArrayChanged() { return mVertexAttribArrayChanged; }
//Methods for CullFace verification
- inline void EnableCullFaceCallTrace(bool enable) { mCullFaceTrace.Enable(enable); }
- inline void ResetCullFaceCallStack() { mCullFaceTrace.Reset(); }
- inline TraceCallStack& GetCullFaceTrace() { return mCullFaceTrace; }
+ inline void EnableCullFaceCallTrace(bool enable)
+ {
+ mCullFaceTrace.Enable(enable);
+ }
+ inline void ResetCullFaceCallStack()
+ {
+ mCullFaceTrace.Reset();
+ }
+ inline TraceCallStack& GetCullFaceTrace()
+ {
+ return mCullFaceTrace;
+ }
//Methods for Enable/Disable call verification
- inline void EnableEnableDisableCallTrace(bool enable) { mEnableDisableTrace.Enable(enable); }
- inline void ResetEnableDisableCallStack() { mEnableDisableTrace.Reset(); }
- inline TraceCallStack& GetEnableDisableTrace() { return mEnableDisableTrace; }
+ inline void EnableEnableDisableCallTrace(bool enable)
+ {
+ mEnableDisableTrace.Enable(enable);
+ }
+ inline void ResetEnableDisableCallStack()
+ {
+ mEnableDisableTrace.Reset();
+ }
+ inline TraceCallStack& GetEnableDisableTrace()
+ {
+ return mEnableDisableTrace;
+ }
//Methods for Shader verification
- inline void EnableShaderCallTrace(bool enable) { mShaderTrace.Enable(enable); }
- inline void ResetShaderCallStack() { mShaderTrace.Reset(); }
- inline TraceCallStack& GetShaderTrace() { return mShaderTrace; }
+ inline void EnableShaderCallTrace(bool enable)
+ {
+ mShaderTrace.Enable(enable);
+ }
+ inline void ResetShaderCallStack()
+ {
+ mShaderTrace.Reset();
+ }
+ inline TraceCallStack& GetShaderTrace()
+ {
+ return mShaderTrace;
+ }
//Methods for Texture verification
- inline void EnableTextureCallTrace(bool enable) { mTextureTrace.Enable(enable); }
- inline void ResetTextureCallStack() { mTextureTrace.Reset(); }
- inline TraceCallStack& GetTextureTrace() { return mTextureTrace; }
+ inline void EnableTextureCallTrace(bool enable)
+ {
+ mTextureTrace.Enable(enable);
+ }
+ inline void ResetTextureCallStack()
+ {
+ mTextureTrace.Reset();
+ }
+ inline TraceCallStack& GetTextureTrace()
+ {
+ return mTextureTrace;
+ }
//Methods for Texture verification
- inline void EnableTexParameterCallTrace(bool enable) { mTexParamaterTrace.Enable(enable); }
- inline void ResetTexParameterCallStack() { mTexParamaterTrace.Reset(); }
- inline TraceCallStack& GetTexParameterTrace() { return mTexParamaterTrace; }
+ inline void EnableTexParameterCallTrace(bool enable)
+ {
+ mTexParamaterTrace.Enable(enable);
+ }
+ inline void ResetTexParameterCallStack()
+ {
+ mTexParamaterTrace.Reset();
+ }
+ inline TraceCallStack& GetTexParameterTrace()
+ {
+ return mTexParamaterTrace;
+ }
//Methods for Draw verification
- inline void EnableDrawCallTrace(bool enable) { mDrawTrace.Enable(enable); }
- inline void ResetDrawCallStack() { mDrawTrace.Reset(); }
- inline TraceCallStack& GetDrawTrace() { return mDrawTrace; }
+ inline void EnableDrawCallTrace(bool enable)
+ {
+ mDrawTrace.Enable(enable);
+ }
+ inline void ResetDrawCallStack()
+ {
+ mDrawTrace.Reset();
+ }
+ inline TraceCallStack& GetDrawTrace()
+ {
+ return mDrawTrace;
+ }
//Methods for Depth function verification
- inline void EnableDepthFunctionCallTrace(bool enable) { mDepthFunctionTrace.Enable(enable); }
- inline void ResetDepthFunctionCallStack() { mDepthFunctionTrace.Reset(); }
- inline TraceCallStack& GetDepthFunctionTrace() { return mDepthFunctionTrace; }
+ inline void EnableDepthFunctionCallTrace(bool enable)
+ {
+ mDepthFunctionTrace.Enable(enable);
+ }
+ inline void ResetDepthFunctionCallStack()
+ {
+ mDepthFunctionTrace.Reset();
+ }
+ inline TraceCallStack& GetDepthFunctionTrace()
+ {
+ return mDepthFunctionTrace;
+ }
//Methods for Stencil function verification
- inline void EnableStencilFunctionCallTrace(bool enable) { mStencilFunctionTrace.Enable(enable); }
- inline void ResetStencilFunctionCallStack() { mStencilFunctionTrace.Reset(); }
- inline TraceCallStack& GetStencilFunctionTrace() { return mStencilFunctionTrace; }
+ inline void EnableStencilFunctionCallTrace(bool enable)
+ {
+ mStencilFunctionTrace.Enable(enable);
+ }
+ inline void ResetStencilFunctionCallStack()
+ {
+ mStencilFunctionTrace.Reset();
+ }
+ inline TraceCallStack& GetStencilFunctionTrace()
+ {
+ return mStencilFunctionTrace;
+ }
//Methods for Scissor verification
- inline void EnableScissorCallTrace(bool enable) { mScissorTrace.Enable(enable); }
- inline void ResetScissorCallStack() { mScissorTrace.Reset(); }
- inline TraceCallStack& GetScissorTrace() { return mScissorTrace; }
+ inline void EnableScissorCallTrace(bool enable)
+ {
+ mScissorTrace.Enable(enable);
+ }
+ inline void ResetScissorCallStack()
+ {
+ mScissorTrace.Reset();
+ }
+ inline TraceCallStack& GetScissorTrace()
+ {
+ return mScissorTrace;
+ }
//Methods for Uniform function verification
- inline void EnableSetUniformCallTrace(bool enable) { mSetUniformTrace.Enable(enable); }
- inline void ResetSetUniformCallStack() { mSetUniformTrace.Reset(); }
- inline TraceCallStack& GetSetUniformTrace() { return mSetUniformTrace; }
+ inline void EnableSetUniformCallTrace(bool enable)
+ {
+ mSetUniformTrace.Enable(enable);
+ }
+ inline void ResetSetUniformCallStack()
+ {
+ mSetUniformTrace.Reset();
+ }
+ inline TraceCallStack& GetSetUniformTrace()
+ {
+ return mSetUniformTrace;
+ }
//Methods for Viewport verification
- inline void EnableViewportCallTrace(bool enable) { mViewportTrace.Enable(enable); }
- inline void ResetViewportCallStack() { mViewportTrace.Reset(); }
- inline TraceCallStack& GetViewportTrace() { return mViewportTrace; }
+ inline void EnableViewportCallTrace(bool enable)
+ {
+ mViewportTrace.Enable(enable);
+ }
+ inline void ResetViewportCallStack()
+ {
+ mViewportTrace.Reset();
+ }
+ inline TraceCallStack& GetViewportTrace()
+ {
+ return mViewportTrace;
+ }
- template <typename T>
- inline bool GetUniformValue( const char* name, T& value ) const
+ template<typename T>
+ inline bool GetUniformValue(const char* name, T& value) const
{
- for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
- program_it != mUniforms.end();
- ++program_it )
+ for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
+ program_it != mUniforms.end();
+ ++program_it)
{
- const UniformIDMap &uniformIDs = program_it->second;
+ const UniformIDMap& uniformIDs = program_it->second;
- UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
- if( uniform_it != uniformIDs.end() )
+ UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
+ if(uniform_it != uniformIDs.end())
{
// found one matching uniform name, lets check the value...
GLuint programId = program_it->first;
- GLint uniformId = uniform_it->second;
+ GLint uniformId = uniform_it->second;
- const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
- return mProgramUniforms.GetUniformValue( programId, uniformId, value );
+ const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
+ return mProgramUniforms.GetUniformValue(programId, uniformId, value);
}
}
return false;
}
-
- template <typename T>
- inline bool CheckUniformValue( const char* name, const T& value ) const
+ template<typename T>
+ inline bool CheckUniformValue(const char* name, const T& value) const
{
- for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
- program_it != mUniforms.end();
- ++program_it )
+ for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
+ program_it != mUniforms.end();
+ ++program_it)
{
- const UniformIDMap &uniformIDs = program_it->second;
+ const UniformIDMap& uniformIDs = program_it->second;
- UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
- if( uniform_it != uniformIDs.end() )
+ UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
+ if(uniform_it != uniformIDs.end())
{
// found one matching uniform name, lets check the value...
GLuint programId = program_it->first;
- GLint uniformId = uniform_it->second;
+ GLint uniformId = uniform_it->second;
- const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
- if( mProgramUniforms.CheckUniformValue( programId, uniformId, value ) )
+ const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
+ if(mProgramUniforms.CheckUniformValue(programId, uniformId, value))
{
// the value matches
return true;
}
}
- fprintf(stderr, "Not found, printing possible values:\n" );
- for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
- program_it != mUniforms.end();
- ++program_it )
+ fprintf(stderr, "Not found, printing possible values:\n");
+ for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
+ program_it != mUniforms.end();
+ ++program_it)
{
- const UniformIDMap &uniformIDs = program_it->second;
+ const UniformIDMap& uniformIDs = program_it->second;
- UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
- if( uniform_it != uniformIDs.end() )
+ UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
+ if(uniform_it != uniformIDs.end())
{
// found one matching uniform name, lets check the value...
GLuint programId = program_it->first;
- GLint uniformId = uniform_it->second;
+ GLint uniformId = uniform_it->second;
- const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( value );
- T origValue;
- if ( mProgramUniforms.GetUniformValue(programId, uniformId, origValue) )
+ const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(value);
+ T origValue;
+ if(mProgramUniforms.GetUniformValue(programId, uniformId, origValue))
{
std::stringstream out;
out << uniform_it->first << ": " << origValue;
- fprintf(stderr, "%s\n", out.str().c_str() );
+ fprintf(stderr, "%s\n", out.str().c_str());
}
}
}
return false;
}
- template <typename T>
- inline bool GetUniformValue( GLuint programId, GLuint uniformId, T& outValue) const
+ template<typename T>
+ inline bool GetUniformValue(GLuint programId, GLuint uniformId, T& outValue) const
{
- const ProgramUniformValue<T> &mProgramUniforms = GetProgramUniformsForType( outValue );
- return mProgramUniforms.GetUniformValue( programId, uniformId, outValue );
+ const ProgramUniformValue<T>& mProgramUniforms = GetProgramUniformsForType(outValue);
+ return mProgramUniforms.GetUniformValue(programId, uniformId, outValue);
}
- inline bool GetUniformIds( const char* name, GLuint& programId, GLuint& uniformId ) const
+ inline bool GetUniformIds(const char* name, GLuint& programId, GLuint& uniformId) const
{
- for( ProgramUniformMap::const_iterator program_it = mUniforms.begin();
- program_it != mUniforms.end();
- ++program_it )
+ for(ProgramUniformMap::const_iterator program_it = mUniforms.begin();
+ program_it != mUniforms.end();
+ ++program_it)
{
- const UniformIDMap &uniformIDs = program_it->second;
+ const UniformIDMap& uniformIDs = program_it->second;
- UniformIDMap::const_iterator uniform_it = uniformIDs.find( name );
- if( uniform_it != uniformIDs.end() )
+ UniformIDMap::const_iterator uniform_it = uniformIDs.find(name);
+ if(uniform_it != uniformIDs.end())
{
programId = program_it->first;
uniformId = uniform_it->second;
struct ScissorParams
{
- GLint x;
- GLint y;
+ GLint x;
+ GLint y;
GLsizei width;
GLsizei height;
- ScissorParams() : x( 0 ), y( 0 ), width( 0 ), height( 0 ) { }
+ ScissorParams()
+ : x(0),
+ y(0),
+ width(0),
+ height(0)
+ {
+ }
};
// Methods to check scissor tests
- inline const ScissorParams& GetScissorParams() const { return mScissorParams; }
+ inline const ScissorParams& GetScissorParams() const
+ {
+ return mScissorParams;
+ }
struct ColorMaskParams
{
GLboolean blue;
GLboolean alpha;
- ColorMaskParams() : red( true ), green( true ), blue( true ), alpha( true ) { }
+ ColorMaskParams()
+ : red(true),
+ green(true),
+ blue(true),
+ alpha(true)
+ {
+ }
};
- inline bool GetProgramBinaryCalled() const { return mGetProgramBinaryCalled; }
+ inline bool GetProgramBinaryCalled() const
+ {
+ return mGetProgramBinaryCalled;
+ }
- inline unsigned int GetClearCountCalled() const { return mClearCount; }
+ inline unsigned int GetClearCountCalled() const
+ {
+ return mClearCount;
+ }
- inline const ColorMaskParams& GetColorMaskParams() const { return mColorMaskParams; }
+ inline const ColorMaskParams& GetColorMaskParams() const
+ {
+ return mColorMaskParams;
+ }
- typedef std::vector<size_t> BufferDataCalls;
- inline const BufferDataCalls& GetBufferDataCalls() const { return mBufferDataCalls; }
- inline void ResetBufferDataCalls() { mBufferDataCalls.clear(); }
+ typedef std::vector<size_t> BufferDataCalls;
+ inline const BufferDataCalls& GetBufferDataCalls() const
+ {
+ return mBufferDataCalls;
+ }
+ inline void ResetBufferDataCalls()
+ {
+ mBufferDataCalls.clear();
+ }
- typedef std::vector<size_t> BufferSubDataCalls;
- inline const BufferSubDataCalls& GetBufferSubDataCalls() const { return mBufferSubDataCalls; }
- inline void ResetBufferSubDataCalls() { mBufferSubDataCalls.clear(); }
+ typedef std::vector<size_t> BufferSubDataCalls;
+ inline const BufferSubDataCalls& GetBufferSubDataCalls() const
+ {
+ return mBufferSubDataCalls;
+ }
+ inline void ResetBufferSubDataCalls()
+ {
+ mBufferSubDataCalls.clear();
+ }
private:
- GLuint mCurrentProgram;
- GLuint mCompileStatus;
- BufferDataCalls mBufferDataCalls;
- BufferSubDataCalls mBufferSubDataCalls;
- GLuint mLinkStatus;
- GLint mNumberOfActiveUniforms;
- GLint mGetAttribLocationResult;
- GLenum mGetErrorResult;
- GLubyte* mGetStringResult;
- GLboolean mIsBufferResult;
- GLboolean mIsEnabledResult;
- GLboolean mIsFramebufferResult;
- GLboolean mIsProgramResult;
- GLboolean mIsRenderbufferResult;
- GLboolean mIsShaderResult;
- GLboolean mIsTextureResult;
- GLenum mActiveTextureUnit;
- GLenum mCheckFramebufferStatusResult;
- GLint mFramebufferStatus;
- GLenum mFramebufferDepthAttached;
- GLenum mFramebufferStencilAttached;
- GLuint mFramebufferColorAttachmentCount;
- GLuint mFrameBufferColorStatus;
- GLint mNumBinaryFormats;
- GLint mBinaryFormats;
- GLint mProgramBinaryLength;
- bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
- bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
- bool mGetProgramBinaryCalled;
- typedef std::map< GLuint, std::string> ShaderSourceMap;
- ShaderSourceMap mShaderSources;
- GLuint mLastShaderCompiled;
- GLbitfield mLastClearBitMask;
- Vector4 mLastClearColor;
- unsigned int mClearCount;
+ GLuint mCurrentProgram;
+ GLuint mCompileStatus;
+ BufferDataCalls mBufferDataCalls;
+ BufferSubDataCalls mBufferSubDataCalls;
+ GLuint mLinkStatus;
+ GLint mNumberOfActiveUniforms;
+ GLint mGetAttribLocationResult;
+ GLenum mGetErrorResult;
+ GLubyte* mGetStringResult;
+ GLboolean mIsBufferResult;
+ GLboolean mIsEnabledResult;
+ GLboolean mIsFramebufferResult;
+ GLboolean mIsProgramResult;
+ GLboolean mIsRenderbufferResult;
+ GLboolean mIsShaderResult;
+ GLboolean mIsTextureResult;
+ GLenum mActiveTextureUnit;
+ GLenum mCheckFramebufferStatusResult;
+ GLint mFramebufferStatus;
+ GLenum mFramebufferDepthAttached;
+ GLenum mFramebufferStencilAttached;
+ GLuint mFramebufferColorAttachmentCount;
+ GLuint mFrameBufferColorStatus;
+ GLint mNumBinaryFormats;
+ GLint mBinaryFormats;
+ GLint mProgramBinaryLength;
+ bool mVertexAttribArrayState[MAX_ATTRIBUTE_CACHE_SIZE];
+ bool mVertexAttribArrayChanged; // whether the vertex attrib array has been changed
+ bool mGetProgramBinaryCalled;
+ typedef std::map<GLuint, std::string> ShaderSourceMap;
+ ShaderSourceMap mShaderSources;
+ GLuint mLastShaderCompiled;
+ GLbitfield mLastClearBitMask;
+ Vector4 mLastClearColor;
+ unsigned int mClearCount;
Vector4 mLastBlendColor;
GLenum mLastBlendEquationRgb;
GLboolean mLastDepthMask;
// Data for manipulating the IDs returned by GenTextures
- GLuint mLastAutoTextureIdUsed;
- GLuint mNumGeneratedTextures;
+ GLuint mLastAutoTextureIdUsed;
+ GLuint mNumGeneratedTextures;
std::vector<GLuint> mNextTextureIds;
std::vector<GLuint> mDeletedTextureIds;
std::vector<GLuint> mBoundTextures;
std::vector<GLuint> mBoundTextures;
};
- ActiveTextureType mActiveTextures[ MIN_TEXTURE_UNIT_LIMIT ];
+ ActiveTextureType mActiveTextures[MIN_TEXTURE_UNIT_LIMIT];
TraceCallStack mCullFaceTrace;
TraceCallStack mEnableDisableTrace;
TraceCallStack mViewportTrace;
// Shaders & Uniforms
- GLuint mLastShaderIdUsed;
- GLuint mLastProgramIdUsed;
- GLuint mLastUniformIdUsed;
- typedef std::map< std::string, GLint > UniformIDMap;
- typedef std::map< GLuint, UniformIDMap > ProgramUniformMap;
- ProgramUniformMap mUniforms;
+ GLuint mLastShaderIdUsed;
+ GLuint mLastProgramIdUsed;
+ GLuint mLastUniformIdUsed;
+ typedef std::map<std::string, GLint> UniformIDMap;
+ typedef std::map<GLuint, UniformIDMap> ProgramUniformMap;
+ ProgramUniformMap mUniforms;
- template <typename T>
- struct ProgramUniformValue : public std::map< GLuint, std::map< GLint, T > >
+ template<typename T>
+ struct ProgramUniformValue : public std::map<GLuint, std::map<GLint, T> >
{
public:
- typedef std::map< GLint, T > UniformValueMap;
- typedef std::map< GLuint, UniformValueMap > Map;
+ typedef std::map<GLint, T> UniformValueMap;
+ typedef std::map<GLuint, UniformValueMap> Map;
- bool SetUniformValue( GLuint program, GLuint uniform, const T& value )
+ bool SetUniformValue(GLuint program, GLuint uniform, const T& value)
{
- if( program == 0 )
+ if(program == 0)
{
return false;
}
- typename Map::iterator it = Map::find( program );
- if( it == Map::end() )
+ typename Map::iterator it = Map::find(program);
+ if(it == Map::end())
{
// if its the first uniform for this program add it
- std::pair< typename Map::iterator, bool > result =
- Map::insert( typename Map::value_type( program, UniformValueMap() ) );
+ std::pair<typename Map::iterator, bool> result =
+ Map::insert(typename Map::value_type(program, UniformValueMap()));
it = result.first;
}
UniformValueMap& uniforms = it->second;
- uniforms[uniform] = value;
+ uniforms[uniform] = value;
return true;
}
- bool CheckUniformValue( GLuint program, GLuint uniform, const T& value ) const
+ bool CheckUniformValue(GLuint program, GLuint uniform, const T& value) const
{
T uniformValue;
- if ( GetUniformValue( program, uniform, uniformValue ) )
+ if(GetUniformValue(program, uniform, uniformValue))
{
return CompareType<T>(value, uniformValue, Math::MACHINE_EPSILON_10);
}
return false;
}
- bool GetUniformValue( GLuint program, GLuint uniform, T& value ) const
+ bool GetUniformValue(GLuint program, GLuint uniform, T& value) const
{
- if( program == 0 )
+ if(program == 0)
{
return false;
}
- typename Map::const_iterator it = Map::find( program );
- if( it == Map::end() )
+ typename Map::const_iterator it = Map::find(program);
+ if(it == Map::end())
{
// Uniform values always initialised as 0
value = GetZero();
return true;
}
- const UniformValueMap& uniforms = it->second;
- typename UniformValueMap::const_iterator it2 = uniforms.find( uniform );
- if( it2 == uniforms.end() )
+ const UniformValueMap& uniforms = it->second;
+ typename UniformValueMap::const_iterator it2 = uniforms.find(uniform);
+ if(it2 == uniforms.end())
{
// Uniform values always initialised as 0
value = GetZero();
T GetZero() const;
};
- ProgramUniformValue<int> mProgramUniforms1i;
- ProgramUniformValue<float> mProgramUniforms1f;
+ ProgramUniformValue<int> mProgramUniforms1i;
+ ProgramUniformValue<float> mProgramUniforms1f;
ProgramUniformValue<Vector2> mProgramUniforms2f;
ProgramUniformValue<Vector3> mProgramUniforms3f;
ProgramUniformValue<Vector4> mProgramUniforms4f;
- ProgramUniformValue<Matrix> mProgramUniformsMat4;
+ ProgramUniformValue<Matrix> mProgramUniformsMat4;
ProgramUniformValue<Matrix3> mProgramUniformsMat3;
- inline const ProgramUniformValue<int>& GetProgramUniformsForType( const int ) const
+ inline const ProgramUniformValue<int>& GetProgramUniformsForType(const int) const
{
return mProgramUniforms1i;
}
- inline const ProgramUniformValue<float>& GetProgramUniformsForType( const float ) const
+ inline const ProgramUniformValue<float>& GetProgramUniformsForType(const float) const
{
return mProgramUniforms1f;
}
- inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType( const Vector2& ) const
+ inline const ProgramUniformValue<Vector2>& GetProgramUniformsForType(const Vector2&) const
{
return mProgramUniforms2f;
}
- inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType( const Vector3& ) const
+ inline const ProgramUniformValue<Vector3>& GetProgramUniformsForType(const Vector3&) const
{
return mProgramUniforms3f;
}
- inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType( const Vector4& ) const
+ inline const ProgramUniformValue<Vector4>& GetProgramUniformsForType(const Vector4&) const
{
return mProgramUniforms4f;
}
- inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType( const Matrix& ) const
+ inline const ProgramUniformValue<Matrix>& GetProgramUniformsForType(const Matrix&) const
{
return mProgramUniformsMat4;
}
- inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType( const Matrix3& ) const
+ inline const ProgramUniformValue<Matrix3>& GetProgramUniformsForType(const Matrix3&) const
{
return mProgramUniformsMat3;
}
inline void SetVertexAttribArray(GLuint index, bool state)
{
- if( index >= MAX_ATTRIBUTE_CACHE_SIZE )
+ if(index >= MAX_ATTRIBUTE_CACHE_SIZE)
{
// out of range
return;
}
- mVertexAttribArrayState[ index ] = state;
- mVertexAttribArrayChanged = true;
+ mVertexAttribArrayState[index] = state;
+ mVertexAttribArrayChanged = true;
}
- ScissorParams mScissorParams;
+ ScissorParams mScissorParams;
ColorMaskParams mColorMaskParams;
};
-template <>
+template<>
inline int TestGlAbstraction::ProgramUniformValue<int>::GetZero() const
{
return 0;
}
-template <>
+template<>
inline float TestGlAbstraction::ProgramUniformValue<float>::GetZero() const
{
return 0.0f;
}
-template <>
+template<>
inline Vector2 TestGlAbstraction::ProgramUniformValue<Vector2>::GetZero() const
{
return Vector2::ZERO;
}
-template <>
+template<>
inline Vector3 TestGlAbstraction::ProgramUniformValue<Vector3>::GetZero() const
{
return Vector3::ZERO;
}
-template <>
+template<>
inline Vector4 TestGlAbstraction::ProgramUniformValue<Vector4>::GetZero() const
{
return Vector4::ZERO;
}
-template <>
+template<>
inline Matrix TestGlAbstraction::ProgramUniformValue<Matrix>::GetZero() const
{
return Matrix();
}
-template <>
+template<>
inline Matrix3 TestGlAbstraction::ProgramUniformValue<Matrix3>::GetZero() const
{
- return Matrix3( Matrix() );
+ return Matrix3(Matrix());
}
} // namespace Dali
bool BlendEnabled(const Dali::TraceCallStack& callStack);
bool BlendDisabled(const Dali::TraceCallStack& callStack);
-
#endif // TEST_GL_ABSTRACTION_H
namespace Dali
{
-
/**
* Class to emulate the GL context helper
*/
-class DALI_CORE_API TestGlContextHelperAbstraction: public Integration::GlContextHelperAbstraction
+class DALI_CORE_API TestGlContextHelperAbstraction : public Integration::GlContextHelperAbstraction
{
public:
/**
* Constructor
*/
- TestGlContextHelperAbstraction() {};
+ TestGlContextHelperAbstraction(){};
/**
* Destructor
*/
- ~TestGlContextHelperAbstraction() {};
+ ~TestGlContextHelperAbstraction() override{};
/**
* @brief Switch to the surfaceless GL context
*/
- virtual void MakeSurfacelessContextCurrent() {};
+ void MakeSurfacelessContextCurrent() override{};
/**
* @brief Clear the GL context
*/
- virtual void MakeContextNull() {};
+ void MakeContextNull() override{};
/**
* @brief Wait until all GL rendering calls for the current GL context are executed
*/
- virtual void WaitClient() {};
-private:
+ void WaitClient() override{};
- TestGlContextHelperAbstraction( const TestGlContextHelperAbstraction& ); ///< Undefined
- TestGlContextHelperAbstraction& operator=( const TestGlContextHelperAbstraction& ); ///< Undefined
+private:
+ TestGlContextHelperAbstraction(const TestGlContextHelperAbstraction&); ///< Undefined
+ TestGlContextHelperAbstraction& operator=(const TestGlContextHelperAbstraction&); ///< Undefined
};
-} // Dali
+} // namespace Dali
#endif // TEST_GL_CONTEXT_HELPER_ABSTRACTION_H
namespace Dali
{
-
TestSyncObject::TestSyncObject(TraceCallStack& trace)
: synced(false),
mTrace(trace)
return synced;
}
-
-
TestGlSyncAbstraction::TestGlSyncAbstraction()
{
Initialize();
*/
TestGlSyncAbstraction::~TestGlSyncAbstraction()
{
- for( SyncIter iter=mSyncObjects.begin(), end=mSyncObjects.end(); iter != end; ++iter )
+ for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
{
delete *iter;
}
* Create a sync object
* @return the sync object
*/
-Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::CreateSyncObject( )
+Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::CreateSyncObject()
{
mTrace.PushCall("CreateSyncObject", ""); // Trace the method
TestSyncObject* syncObject = new TestSyncObject(mTrace);
- mSyncObjects.push_back( syncObject );
+ mSyncObjects.push_back(syncObject);
return syncObject;
}
* Destroy a sync object
* @param[in] syncObject The object to destroy
*/
-void TestGlSyncAbstraction::DestroySyncObject( Integration::GlSyncAbstraction::SyncObject* syncObject )
+void TestGlSyncAbstraction::DestroySyncObject(Integration::GlSyncAbstraction::SyncObject* syncObject)
{
std::stringstream out;
out << syncObject;
mTrace.PushCall("DestroySyncObject", out.str()); // Trace the method
- for( SyncIter iter=mSyncObjects.begin(), end=mSyncObjects.end(); iter != end; ++iter )
+ for(SyncIter iter = mSyncObjects.begin(), end = mSyncObjects.end(); iter != end; ++iter)
{
- if( *iter == syncObject )
+ if(*iter == syncObject)
{
delete *iter;
mSyncObjects.erase(iter);
}
}
-
-Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::GetLastSyncObject( )
+Integration::GlSyncAbstraction::SyncObject* TestGlSyncAbstraction::GetLastSyncObject()
{
- if( !mSyncObjects.empty() )
+ if(!mSyncObjects.empty())
{
return mSyncObjects.back();
}
* @param[in]
* @param[in] sync The sync value to set
*/
-void TestGlSyncAbstraction::SetObjectSynced( Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync )
+void TestGlSyncAbstraction::SetObjectSynced(Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync)
{
TestSyncObject* testSyncObject = static_cast<TestSyncObject*>(syncObject);
- testSyncObject->synced = sync;
+ testSyncObject->synced = sync;
}
/**
* Turn trace on
*/
-void TestGlSyncAbstraction::EnableTrace(bool enable) { mTrace.Enable(enable); }
+void TestGlSyncAbstraction::EnableTrace(bool enable)
+{
+ mTrace.Enable(enable);
+}
/**
* Reset the trace callstack
*/
-void TestGlSyncAbstraction::ResetTrace() { mTrace.Reset(); }
+void TestGlSyncAbstraction::ResetTrace()
+{
+ mTrace.Reset();
+}
/**
* Get the trace object (allows test case to find methods on it)
*/
-TraceCallStack& TestGlSyncAbstraction::GetTrace() { return mTrace; }
+TraceCallStack& TestGlSyncAbstraction::GetTrace()
+{
+ return mTrace;
+}
int32_t TestGlSyncAbstraction::GetNumberOfSyncObjects()
{
- return static_cast<int32_t>( mSyncObjects.size() );
+ return static_cast<int32_t>(mSyncObjects.size());
}
-
-} // Dali
+} // namespace Dali
#define TEST_GL_SYNC_ABSTRACTION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
+#include <map>
#include <sstream>
#include <string>
-#include <map>
// INTERNAL INCLUDES
#include <dali/integration-api/core.h>
#include <dali/integration-api/gl-sync-abstraction.h>
+
#include "test-trace-call-stack.h"
namespace Dali
{
-
class DALI_CORE_API TestSyncObject : public Integration::GlSyncAbstraction::SyncObject
{
public:
TestSyncObject(TraceCallStack& trace);
- ~TestSyncObject();
- bool IsSynced();
- bool synced;
+ ~TestSyncObject() override;
+ bool IsSynced() override;
+ bool synced;
TraceCallStack& mTrace;
};
/**
* Class to emulate the GL sync functions with tracing
*/
-class DALI_CORE_API TestGlSyncAbstraction: public Integration::GlSyncAbstraction
+class DALI_CORE_API TestGlSyncAbstraction : public Integration::GlSyncAbstraction
{
public:
/**
/**
* Destructor
*/
- ~TestGlSyncAbstraction();
+ ~TestGlSyncAbstraction() override;
/**
* Initialize the sync objects - clear down the map
* Create a sync object
* @return the sync object
*/
- virtual Integration::GlSyncAbstraction::SyncObject* CreateSyncObject( );
+ Integration::GlSyncAbstraction::SyncObject* CreateSyncObject() override;
/**
* Destroy a sync object
* @param[in] syncObject The object to destroy
*/
- virtual void DestroySyncObject( Integration::GlSyncAbstraction::SyncObject* syncObject );
-
+ void DestroySyncObject(Integration::GlSyncAbstraction::SyncObject* syncObject) override;
public: // TEST FUNCTIONS
- Integration::GlSyncAbstraction::SyncObject* GetLastSyncObject( );
+ Integration::GlSyncAbstraction::SyncObject* GetLastSyncObject();
/**
* Test method to trigger the object sync behaviour.
* @param[in]
* @param[in] sync The sync value to set
*/
- void SetObjectSynced( Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync );
+ void SetObjectSynced(Integration::GlSyncAbstraction::SyncObject* syncObject, bool sync);
/**
* Turn trace on
int32_t GetNumberOfSyncObjects();
private:
+ TestGlSyncAbstraction(const TestGlSyncAbstraction&); ///< Undefined
+ TestGlSyncAbstraction& operator=(const TestGlSyncAbstraction&); ///< Undefined
- TestGlSyncAbstraction( const TestGlSyncAbstraction& ); ///< Undefined
- TestGlSyncAbstraction& operator=( const TestGlSyncAbstraction& ); ///< Undefined
-
- typedef std::vector<TestSyncObject*> SyncContainer;
- typedef SyncContainer::iterator SyncIter;
- SyncContainer mSyncObjects; ///< The sync objects
- TraceCallStack mTrace; ///< the trace call stack for testing
+ typedef std::vector<TestSyncObject*> SyncContainer;
+ typedef SyncContainer::iterator SyncIter;
+ SyncContainer mSyncObjects; ///< The sync objects
+ TraceCallStack mTrace; ///< the trace call stack for testing
};
-} // Dali
+} // namespace Dali
#endif // TEST_GL_SYNC_ABSTRACTION_H
*/
#include "test-harness.h"
+
+#include <fcntl.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
+#include <testcase.h>
#include <unistd.h>
-#include <vector>
-#include <map>
+
#include <cstring>
-#include <testcase.h>
-#include <fcntl.h>
+#include <map>
+#include <vector>
namespace TestHarness
{
-
typedef std::map<int32_t, TestCase> RunningTestCases;
const char* basename(const char* path)
{
- const char* ptr=path;
- const char* slash=NULL;
- for( ; *ptr != '\0' ; ++ptr )
+ const char* ptr = path;
+ const char* slash = NULL;
+ for(; *ptr != '\0'; ++ptr)
{
- if(*ptr == '/') slash=ptr;
+ if(*ptr == '/') slash = ptr;
}
if(slash != NULL) ++slash;
return slash;
open("/dev/null", O_RDWR); // Redirect file descriptor number 2 (i.e. stderr) to /dev/null
}
-int32_t RunTestCase( struct ::testcase_s& testCase )
+int32_t RunTestCase(struct ::testcase_s& testCase)
{
int32_t result = EXIT_STATUS_TESTCASE_FAILED;
-// dont want to catch exception as we want to be able to get
-// gdb stack trace from the first error
-// by default tests should all always pass with no exceptions
- if( testCase.startup )
+ // dont want to catch exception as we want to be able to get
+ // gdb stack trace from the first error
+ // by default tests should all always pass with no exceptions
+ if(testCase.startup)
{
testCase.startup();
}
{
result = testCase.function();
}
- catch( const char* )
+ catch(const char*)
{
// just catch test fail exception, return is already set to EXIT_STATUS_TESTCASE_FAILED
}
- if( testCase.cleanup )
+ if(testCase.cleanup)
{
testCase.cleanup();
}
return result;
}
-
-int32_t RunTestCaseInChildProcess( struct ::testcase_s& testCase, bool suppressOutput )
+int32_t RunTestCaseInChildProcess(struct ::testcase_s& testCase, bool suppressOutput)
{
int32_t testResult = EXIT_STATUS_TESTCASE_FAILED;
int32_t pid = fork();
- if( pid == 0 ) // Child process
+ if(pid == 0) // Child process
{
- if( suppressOutput )
+ if(suppressOutput)
{
SuppressLogOutput();
}
else
{
printf("\n");
- for(int32_t i=0; i<80; ++i) printf("#");
+ for(int32_t i = 0; i < 80; ++i) printf("#");
printf("\nTC: %s\n", testCase.name);
fflush(stdout);
}
- int32_t status = RunTestCase( testCase );
+ int32_t status = RunTestCase(testCase);
- if( ! suppressOutput )
+ if(!suppressOutput)
{
fflush(stdout);
fflush(stderr);
fclose(stdout);
fclose(stderr);
}
- exit( status );
+ exit(status);
}
else if(pid == -1)
{
}
else // Parent process
{
- int32_t status = 0;
+ int32_t status = 0;
int32_t childPid = waitpid(pid, &status, 0);
- if( childPid == -1 )
+ if(childPid == -1)
{
perror("waitpid");
exit(EXIT_STATUS_WAITPID_FAILED);
}
- if( WIFEXITED(status) )
+ if(WIFEXITED(status))
{
- if( childPid > 0 )
+ if(childPid > 0)
{
testResult = WEXITSTATUS(status);
- if( testResult )
+ if(testResult)
{
printf("Test case %s failed: %d\n", testCase.name, testResult);
}
}
}
- else if(WIFSIGNALED(status) )
+ else if(WIFSIGNALED(status))
{
int32_t signal = WTERMSIG(status);
- testResult = EXIT_STATUS_TESTCASE_ABORTED;
- if( signal == SIGABRT )
+ testResult = EXIT_STATUS_TESTCASE_ABORTED;
+ if(signal == SIGABRT)
{
- printf("Test case %s failed: test case asserted\n", testCase.name );
+ printf("Test case %s failed: test case asserted\n", testCase.name);
}
else
{
return testResult;
}
-void OutputStatistics( const char* processName, int32_t numPasses, int32_t numFailures )
+void OutputStatistics(const char* processName, int32_t numPasses, int32_t numFailures)
{
- FILE* fp=fopen("summary.xml", "a");
- if( fp != NULL )
+ FILE* fp = fopen("summary.xml", "a");
+ if(fp != NULL)
{
- fprintf( fp,
- " <suite name=\"%s\">\n"
- " <total_case>%d</total_case>\n"
-
" <pass_case>%d</pass_case>\n"
-
" <pass_rate>%5.2f</pass_rate>\n"
- " <fail_case>%d</fail_case>\n"
- " <fail_rate>%5.2f</fail_rate>\n"
- " <block_case>0</block_case>\n"
- " <block_rate>0.00</block_rate>\n"
- " <na_case>0</na_case>\n"
- " <na_rate>0.00</na_rate>\n"
- " </suite>\n",
- basename(processName),
- numPasses+numFailures,
- numPasses,
- (float)numPasses/(numPasses+numFailures),
- numFailures,
- (float)numFailures/(numPasses+numFailures) );
+ fprintf(fp,
+ " <suite name=\"%s\">\n"
+ " <total_case>%d</total_case>\n"
+ " <pass_case>%d</pass_case>\n"
+ " <pass_rate>%5.2f</pass_rate>\n"
+ " <fail_case>%d</fail_case>\n"
+ " <fail_rate>%5.2f</fail_rate>\n"
+ " <block_case>0</block_case>\n"
+ " <block_rate>0.00</block_rate>\n"
+ " <na_case>0</na_case>\n"
+ " <na_rate>0.00</na_rate>\n"
+ " </suite>\n",
+ basename(processName),
+ numPasses + numFailures,
+ numPasses,
+ (float)numPasses / (numPasses + numFailures),
+ numFailures,
+ (float)numFailures / (numPasses + numFailures));
fclose(fp);
}
}
-int32_t RunAll( const char* processName, ::testcase tc_array[] )
+int32_t RunAll(const char* processName, ::testcase tc_array[])
{
int32_t numFailures = 0;
- int32_t numPasses = 0;
+ int32_t numPasses = 0;
// Run test cases in child process( to kill output/handle signals ), but run serially.
- for( uint32_t i=0; tc_array[i].name; i++)
+ for(uint32_t i = 0; tc_array[i].name; i++)
{
- int32_t result = RunTestCaseInChildProcess( tc_array[i], false );
- if( result == 0 )
+ int32_t result = RunTestCaseInChildProcess(tc_array[i], false);
+ if(result == 0)
{
numPasses++;
}
}
}
- OutputStatistics( processName, numPasses, numFailures);
+ OutputStatistics(processName, numPasses, numFailures);
return numFailures;
}
// Constantly runs up to MAX_NUM_CHILDREN processes
-int32_t RunAllInParallel( const char* processName, ::testcase tc_array[], bool reRunFailed)
+int32_t RunAllInParallel(const char* processName, ::testcase tc_array[], bool reRunFailed)
{
int32_t numFailures = 0;
- int32_t numPasses = 0;
+ int32_t numPasses = 0;
- RunningTestCases children;
+ RunningTestCases children;
std::vector<int32_t> failedTestCases;
// Fork up to MAX_NUM_CHILDREN processes, then
// wait. As soon as a proc completes, fork the next.
- int32_t nextTestCase = 0;
+ int32_t nextTestCase = 0;
int32_t numRunningChildren = 0;
- while( tc_array[nextTestCase].name || numRunningChildren > 0)
+ while(tc_array[nextTestCase].name || numRunningChildren > 0)
{
// Create more children (up to the max number or til the end of the array)
- while( numRunningChildren < MAX_NUM_CHILDREN && tc_array[nextTestCase].name )
+ while(numRunningChildren < MAX_NUM_CHILDREN && tc_array[nextTestCase].name)
{
int32_t pid = fork();
- if( pid == 0 ) // Child process
+ if(pid == 0) // Child process
{
SuppressLogOutput();
- exit( RunTestCase( tc_array[nextTestCase] ) );
+ exit(RunTestCase(tc_array[nextTestCase]));
}
else if(pid == -1)
{
// Wait for the next child to finish
- int32_t status=0;
+ int32_t status = 0;
int32_t childPid = waitpid(-1, &status, 0);
- if( childPid == -1 )
+ if(childPid == -1)
{
perror("waitpid");
exit(EXIT_STATUS_WAITPID_FAILED);
}
- if( WIFEXITED(status) )
+ if(WIFEXITED(status))
{
- if( childPid > 0 )
+ if(childPid > 0)
{
int32_t testResult = WEXITSTATUS(status);
- if( testResult )
+ if(testResult)
{
printf("Test case %s failed: %d\n", children[childPid].testCaseName, testResult);
failedTestCases.push_back(children[childPid].testCase);
}
}
- else if( WIFSIGNALED(status) || WIFSTOPPED(status))
+ else if(WIFSIGNALED(status) || WIFSTOPPED(status))
{
- status = WIFSIGNALED(status)?WTERMSIG(status):WSTOPSIG(status);
+ status = WIFSIGNALED(status) ? WTERMSIG(status) : WSTOPSIG(status);
- if( childPid > 0 )
+ if(childPid > 0)
{
RunningTestCases::iterator iter = children.find(childPid);
- if( iter != children.end() )
+ if(iter != children.end())
{
printf("Test case %s exited with signal %s\n", iter->second.testCaseName, strsignal(status));
failedTestCases.push_back(iter->second.testCase);
}
}
- OutputStatistics( processName, numPasses, numFailures );
+ OutputStatistics(processName, numPasses, numFailures);
- if( reRunFailed )
+ if(reRunFailed)
{
- for( uint32_t i=0; i<failedTestCases.size(); i++)
+ for(uint32_t i = 0; i < failedTestCases.size(); i++)
{
- char* testCaseStrapline;
- int32_t numChars = asprintf(&testCaseStrapline, "Test case %s", tc_array[failedTestCases[i]].name );
+ char* testCaseStrapline;
+ int32_t numChars = asprintf(&testCaseStrapline, "Test case %s", tc_array[failedTestCases[i]].name);
printf("\n%s\n", testCaseStrapline);
- for(int32_t j=0; j<numChars; j++)
+ for(int32_t j = 0; j < numChars; j++)
{
printf("=");
}
printf("\n");
- RunTestCaseInChildProcess( tc_array[failedTestCases[i] ], false );
+ RunTestCaseInChildProcess(tc_array[failedTestCases[i]], false);
}
}
return numFailures;
}
-
-
int32_t FindAndRunTestCase(::testcase tc_array[], const char* testCaseName)
{
int32_t result = EXIT_STATUS_TESTCASE_NOT_FOUND;
- for( int32_t i = 0; tc_array[i].name; i++ )
+ for(int32_t i = 0; tc_array[i].name; i++)
{
- if( !strcmp(testCaseName, tc_array[i].name) )
+ if(!strcmp(testCaseName, tc_array[i].name))
{
- return RunTestCase( tc_array[i] );
+ return RunTestCase(tc_array[i]);
}
}
void Usage(const char* program)
{
- printf("Usage: \n"
- " %s <testcase name>\t\t Execute a test case\n"
- " %s \t\t Execute all test cases in parallel\n"
- " %s -r\t\t Execute all test cases in parallel, rerunning failed test cases\n"
- " %s -s\t\t Execute all test cases serially\n",
- program, program, program, program);
+ printf(
+ "Usage: \n"
+ " %s <testcase name>\t\t Execute a test case\n"
+ " %s \t\t Execute all test cases in parallel\n"
+ " %s -r\t\t Execute all test cases in parallel, rerunning failed test cases\n"
+ " %s -s\t\t Execute all test cases serially\n",
+ program,
+ program,
+ program,
+ program);
}
-} // namespace
+} // namespace TestHarness
#define TEST_HARNESS_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <stdio.h>
#include <testcase.h>
+
#include <cstdint>
namespace TestHarness
{
-
enum ExitStatus
{
- EXIT_STATUS_TESTCASE_SUCCEEDED, // 0
- EXIT_STATUS_TESTCASE_FAILED, // 1
- EXIT_STATUS_TESTCASE_ABORTED, // 2
- EXIT_STATUS_FORK_FAILED, // 3
- EXIT_STATUS_WAITPID_FAILED, // 4
- EXIT_STATUS_BAD_ARGUMENT, // 5
- EXIT_STATUS_TESTCASE_NOT_FOUND // 6
+ EXIT_STATUS_TESTCASE_SUCCEEDED, // 0
+ EXIT_STATUS_TESTCASE_FAILED, // 1
+ EXIT_STATUS_TESTCASE_ABORTED, // 2
+ EXIT_STATUS_FORK_FAILED, // 3
+ EXIT_STATUS_WAITPID_FAILED, // 4
+ EXIT_STATUS_BAD_ARGUMENT, // 5
+ EXIT_STATUS_TESTCASE_NOT_FOUND // 6
};
const int32_t MAX_NUM_CHILDREN(16);
struct TestCase
{
- int32_t testCase;
+ int32_t testCase;
const char* testCaseName;
TestCase()
}
TestCase& operator=(const TestCase& rhs)
{
- testCase = rhs.testCase;
+ testCase = rhs.testCase;
testCaseName = rhs.testCaseName;
return *this;
-
}
};
* Run a test case
* @param[in] testCase The Testkit-lite test case to run
*/
-int32_t RunTestCase( struct testcase_s& testCase );
+int32_t RunTestCase(struct testcase_s& testCase);
/**
* Run all test cases in parallel
* @param[in] tc_array The array of auto-generated testkit-lite test cases
* @return 0 on success
*/
-int32_t RunAll( const char* processName, testcase tc_array[] );
+int32_t RunAll(const char* processName, testcase tc_array[]);
/**
* Find the named test case in the given array, and run it
#define TEST_INTRUSIVE_PTR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
namespace Dali
{
-
-template <typename T>
+template<typename T>
struct UtcCoverageIntrusivePtr
{
typedef IntrusivePtr<T> (*Creator)();
- void Check( Creator creator)
+ void Check(Creator creator)
{
IntrusivePtr<T> a = creator();
IntrusivePtr<T> b = creator();
- DALI_TEST_CHECK( a.Get() );
+ DALI_TEST_CHECK(a.Get());
a.Reset();
DALI_TEST_CHECK(a);
a.Reset();
-
};
-
};
-} // Dali
+} // namespace Dali
#endif // TEST_INTRUSIVE_PTR_H
-
-
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 "test-application.h"
-#include "test-native-image.h"
+#include "test-native-image.h"
namespace Dali
{
-
TestNativeImagePointer TestNativeImage::New(uint32_t width, uint32_t height)
{
return new TestNativeImage(width, height);
}
TestNativeImage::TestNativeImage(uint32_t width, uint32_t height)
-: mWidth(width), mHeight(height), mExtensionCreateCalls(0), mExtensionDestroyCalls(0), mTargetTextureCalls(0),createResult(true)
+: mWidth(width),
+ mHeight(height),
+ mExtensionCreateCalls(0),
+ mExtensionDestroyCalls(0),
+ mTargetTextureCalls(0),
+ createResult(true)
{
}
{
}
-} // namespace dali
+} // namespace Dali
#define TEST_NATIVE_IMAGE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/public-api/images/native-image-interface.h>
+
#include <dali/integration-api/gl-defines.h>
namespace Dali
public:
static TestNativeImagePointer New(uint32_t width, uint32_t height);
- inline void SetGlExtensionCreateResult(bool result){ createResult = result;}
- inline virtual bool CreateResource() { ++mExtensionCreateCalls; return createResult;};
- inline virtual void DestroyResource() { ++mExtensionDestroyCalls; };
- inline virtual GLenum TargetTexture() { ++mTargetTextureCalls; return mTargetTextureError;};
- inline virtual void PrepareTexture() {};
- inline virtual uint32_t GetWidth() const {return mWidth;};
- inline virtual uint32_t GetHeight() const {return mHeight;};
- inline virtual bool RequiresBlending() const {return true;};
- inline virtual int GetTextureTarget() const {return GL_TEXTURE_EXTERNAL_OES;};
- inline virtual const char* GetCustomFragmentPrefix() const {return "#extension GL_OES_EGL_image_external:require\n";};
- inline const char* GetCustomSamplerTypename() const override { return "samplerExternalOES"; };
+ inline void SetGlExtensionCreateResult(bool result)
+ {
+ createResult = result;
+ }
+ inline virtual bool CreateResource()
+ {
+ ++mExtensionCreateCalls;
+ return createResult;
+ };
+ inline virtual void DestroyResource()
+ {
+ ++mExtensionDestroyCalls;
+ };
+ inline virtual GLenum TargetTexture()
+ {
+ ++mTargetTextureCalls;
+ return mTargetTextureError;
+ };
+ inline virtual void PrepareTexture(){};
+ inline virtual uint32_t GetWidth() const
+ {
+ return mWidth;
+ };
+ inline virtual uint32_t GetHeight() const
+ {
+ return mHeight;
+ };
+ inline virtual bool RequiresBlending() const
+ {
+ return true;
+ };
+ inline virtual int GetTextureTarget() const
+ {
+ return GL_TEXTURE_EXTERNAL_OES;
+ };
+ inline virtual const char* GetCustomFragmentPrefix() const
+ {
+ return "#extension GL_OES_EGL_image_external:require\n";
+ };
+ inline const char* GetCustomSamplerTypename() const override
+ {
+ return "samplerExternalOES";
+ };
- inline Any GetNativeImageHandle() const override { return nullptr; };
- inline bool SourceChanged() const override { return false; };
+ inline Any GetNativeImageHandle() const override
+ {
+ return nullptr;
+ };
+ inline bool SourceChanged() const override
+ {
+ return false;
+ };
- inline virtual Dali::NativeImageInterface::Extension* GetExtension() {return nullptr;}
+ inline virtual Dali::NativeImageInterface::Extension* GetExtension()
+ {
+ return nullptr;
+ }
private:
TestNativeImage(uint32_t width, uint32_t height);
uint32_t mWidth;
uint32_t mHeight;
+
public:
- int32_t mExtensionCreateCalls;
- int32_t mExtensionDestroyCalls;
- int32_t mTargetTextureCalls;
- uint32_t mTargetTextureError=0u;
- bool createResult;
+ int32_t mExtensionCreateCalls;
+ int32_t mExtensionDestroyCalls;
+ int32_t mTargetTextureCalls;
+ uint32_t mTargetTextureError = 0u;
+ bool createResult;
};
-
-
-} // Dali
+} // namespace Dali
#endif // TEST_NATIVE_IMAGE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 "test-platform-abstraction.h"
-#include "dali-test-suite-utils.h"
+
#include <dali/integration-api/bitmap.h>
+#include "dali-test-suite-utils.h"
+
namespace Dali
{
-
TestPlatformAbstraction::TestPlatformAbstraction()
: mTrace(),
- mIsLoadingResult( false ),
+ mIsLoadingResult(false),
mClosestSize(),
mLoadFileResult(),
- mSaveFileResult( false ),
+ mSaveFileResult(false),
mSynchronouslyLoadedResource(),
mTimerId(0),
mCallbackFunction(nullptr)
{
}
-ImageDimensions TestPlatformAbstraction::GetClosestImageSize( const std::string& filename,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection )
+ImageDimensions TestPlatformAbstraction::GetClosestImageSize(const std::string& filename,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection)
{
- ImageDimensions closestSize = ImageDimensions( mClosestSize );
+ ImageDimensions closestSize = ImageDimensions(mClosestSize);
mTrace.PushCall("GetClosestImageSize", "");
return closestSize;
}
-ImageDimensions TestPlatformAbstraction::GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection )
+ImageDimensions TestPlatformAbstraction::GetClosestImageSize(Integration::ResourcePointer resourceBuffer,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection)
{
- ImageDimensions closestSize = ImageDimensions( mClosestSize );
+ ImageDimensions closestSize = ImageDimensions(mClosestSize);
mTrace.PushCall("GetClosestImageSize", "");
return closestSize;
}
-Integration::ResourcePointer TestPlatformAbstraction::LoadImageSynchronously( const Integration::BitmapResourceType& resourceType, const std::string& resourcePath )
+Integration::ResourcePointer TestPlatformAbstraction::LoadImageSynchronously(const Integration::BitmapResourceType& resourceType, const std::string& resourcePath)
{
mTrace.PushCall("LoadResourceSynchronously", "");
return mSynchronouslyLoadedResource;
}
-Integration::BitmapPtr TestPlatformAbstraction::DecodeBuffer( const Integration::BitmapResourceType& resourceType, uint8_t * buffer, size_t size )
+Integration::BitmapPtr TestPlatformAbstraction::DecodeBuffer(const Integration::BitmapResourceType& resourceType, uint8_t* buffer, size_t size)
{
mTrace.PushCall("DecodeBuffer", "");
return mDecodedBitmap;
}
-bool TestPlatformAbstraction::LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const
+bool TestPlatformAbstraction::LoadShaderBinaryFile(const std::string& filename, Dali::Vector<unsigned char>& buffer) const
{
mTrace.PushCall("LoadShaderBinaryFile", "");
- if( mLoadFileResult.loadResult )
+ if(mLoadFileResult.loadResult)
{
buffer = mLoadFileResult.buffer;
}
{
mTrace.Reset();
mTrace.Enable(true);
- mIsLoadingResult=false;
+ mIsLoadingResult = false;
mSynchronouslyLoadedResource.Reset();
mDecodedBitmap.Reset();
}
{
switch(func)
{
- case LoadResourceSynchronouslyFunc: return mTrace.FindMethod("LoadResourceSynchronously");
- case LoadShaderBinaryFileFunc: return mTrace.FindMethod("LoadShaderBinaryFile");
- case SaveShaderBinaryFileFunc: return mTrace.FindMethod("SaveShaderBinaryFile");
+ case LoadResourceSynchronouslyFunc:
+ return mTrace.FindMethod("LoadResourceSynchronously");
+ case LoadShaderBinaryFileFunc:
+ return mTrace.FindMethod("LoadShaderBinaryFile");
+ case SaveShaderBinaryFileFunc:
+ return mTrace.FindMethod("SaveShaderBinaryFile");
}
return false;
}
mDecodedBitmap.Reset();
}
-void TestPlatformAbstraction::SetClosestImageSize( const Vector2& size )
+void TestPlatformAbstraction::SetClosestImageSize(const Vector2& size)
{
- mClosestSize = ImageDimensions( static_cast<uint32_t>( size.x ), static_cast<uint32_t>( size.y ) );
+ mClosestSize = ImageDimensions(static_cast<uint32_t>(size.x), static_cast<uint32_t>(size.y));
}
-void TestPlatformAbstraction::SetLoadFileResult( bool result, Dali::Vector< unsigned char >& buffer )
+void TestPlatformAbstraction::SetLoadFileResult(bool result, Dali::Vector<unsigned char>& buffer)
{
mLoadFileResult.loadResult = result;
- if( result )
+ if(result)
{
mLoadFileResult.buffer = buffer;
}
}
-void TestPlatformAbstraction::SetSaveFileResult( bool result )
+void TestPlatformAbstraction::SetSaveFileResult(bool result)
{
mSaveFileResult = result;
}
-void TestPlatformAbstraction::SetSynchronouslyLoadedResource( Integration::ResourcePointer resource )
+void TestPlatformAbstraction::SetSynchronouslyLoadedResource(Integration::ResourcePointer resource)
{
mSynchronouslyLoadedResource = resource;
}
-void TestPlatformAbstraction::SetDecodedBitmap( Integration::BitmapPtr bitmap )
+void TestPlatformAbstraction::SetDecodedBitmap(Integration::BitmapPtr bitmap)
{
mDecodedBitmap = bitmap;
}
-uint32_t TestPlatformAbstraction::StartTimer( uint32_t milliseconds, CallbackBase* callback )
+uint32_t TestPlatformAbstraction::StartTimer(uint32_t milliseconds, CallbackBase* callback)
{
mCallbackFunction = callback;
mTimerId++;
void TestPlatformAbstraction::TriggerTimer()
{
- if (mCallbackFunction != nullptr)
+ if(mCallbackFunction != nullptr)
{
- CallbackBase::Execute( *mCallbackFunction );
+ CallbackBase::Execute(*mCallbackFunction);
}
}
-void TestPlatformAbstraction::CancelTimer ( uint32_t timerId )
+void TestPlatformAbstraction::CancelTimer(uint32_t timerId)
{
mCallbackFunction = nullptr;
}
#define DALI_TEST_PLATFORM_ABSTRACTION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// EXTERNAL INCLUDES
#include <stdint.h>
+
#include <cstring>
#include <string>
#include <vector>
namespace Dali
{
-
/**
* Concrete implementation of the platform abstraction class.
*/
class DALI_CORE_API TestPlatformAbstraction : public Dali::Integration::PlatformAbstraction
{
-
public:
-
/**
* Constructor
*/
/**
* Destructor
*/
- virtual ~TestPlatformAbstraction();
+ ~TestPlatformAbstraction() override;
/**
* @copydoc PlatformAbstraction::GetClosestImageSize()
*/
- virtual ImageDimensions GetClosestImageSize( const std::string& filename,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection );
+ ImageDimensions GetClosestImageSize(const std::string& filename,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection) override;
/**
* @copydoc PlatformAbstraction::GetClosestImageSize()
*/
- virtual ImageDimensions GetClosestImageSize( Integration::ResourcePointer resourceBuffer,
- ImageDimensions size,
- FittingMode::Type fittingMode,
- SamplingMode::Type samplingMode,
- bool orientationCorrection );
+ ImageDimensions GetClosestImageSize(Integration::ResourcePointer resourceBuffer,
+ ImageDimensions size,
+ FittingMode::Type fittingMode,
+ SamplingMode::Type samplingMode,
+ bool orientationCorrection) override;
/**
* @copydoc PlatformAbstraction::LoadResourceSynchronously()
*/
- virtual Integration::ResourcePointer LoadImageSynchronously( const Integration::BitmapResourceType& resourceType, const std::string& resourcePath );
+ Integration::ResourcePointer LoadImageSynchronously(const Integration::BitmapResourceType& resourceType, const std::string& resourcePath) override;
/**
* @copydoc PlatformAbstraction::DecodeBuffer()
*/
- virtual Integration::BitmapPtr DecodeBuffer( const Dali::Integration::BitmapResourceType& resourceType, uint8_t * buffer, size_t size );
+ Integration::BitmapPtr DecodeBuffer(const Dali::Integration::BitmapResourceType& resourceType, uint8_t* buffer, size_t size) override;
/**
* @copydoc PlatformAbstraction::LoadShaderBinaryFile()
*/
- virtual bool LoadShaderBinaryFile( const std::string& filename, Dali::Vector< unsigned char >& buffer ) const;
+ bool LoadShaderBinaryFile(const std::string& filename, Dali::Vector<unsigned char>& buffer) const override;
/**
* @copydoc PlatformAbstraction::SaveShaderBinaryFile()
*/
- virtual bool SaveShaderBinaryFile( const std::string& filename, const unsigned char * buffer, unsigned int numBytes ) const { return true; }
+ virtual bool SaveShaderBinaryFile(const std::string& filename, const unsigned char* buffer, unsigned int numBytes) const override
+ {
+ return true;
+ }
/**
* @copydoc PlatformAbstraction::StartTimer()
*/
- virtual uint32_t StartTimer( uint32_t milliseconds, CallbackBase* callback );
+ uint32_t StartTimer(uint32_t milliseconds, CallbackBase* callback) override;
/*
* @copydoc PlatformAbstraction::CancelTimer()
*/
- virtual void CancelTimer ( uint32_t timerId );
+ void CancelTimer(uint32_t timerId) override;
public: // TEST FUNCTIONS
-
// Enumeration of Platform Abstraction methods
typedef enum
{
/** Call this every test */
void Initialize();
- inline void EnableTrace(bool enable) { mTrace.Enable(enable); }
- inline void ResetTrace() { mTrace.Reset(); }
- inline TraceCallStack& GetTrace() { return mTrace; }
+ inline void EnableTrace(bool enable)
+ {
+ mTrace.Enable(enable);
+ }
+ inline void ResetTrace()
+ {
+ mTrace.Reset();
+ }
+ inline TraceCallStack& GetTrace()
+ {
+ return mTrace;
+ }
/**
* @brief Checks if a platform function was called
* @brief Sets the value returned by GetClosestImageSize.
* @param[in] size The size that should be returned.
*/
- void SetClosestImageSize( const Vector2& size );
+ void SetClosestImageSize(const Vector2& size);
/**
* @brief Sets the result return by LoadFile.
* @param[in] result The value that LoadFile should return.
* @param[in] buffer The buffer of the loaded file.
*/
- void SetLoadFileResult( bool result, Dali::Vector< unsigned char >& buffer );
+ void SetLoadFileResult(bool result, Dali::Vector<unsigned char>& buffer);
/**
* @brief Sets the SaveFile result
* @param[in] result The value that SaveFile should return
*/
- void SetSaveFileResult( bool result );
+ void SetSaveFileResult(bool result);
/**
* @brief Sets the resource loaded by LoadResourceSynchronously
* @param[in] resource The loaded resource
*/
- void SetSynchronouslyLoadedResource( Integration::ResourcePointer resource );
+ void SetSynchronouslyLoadedResource(Integration::ResourcePointer resource);
/**
* @brief Sets the bitmap returned by DecodeBuffer()
* @param[in] bitmap The decoded bitmap
*/
- void SetDecodedBitmap( Integration::BitmapPtr bitmap );
+ void SetDecodedBitmap(Integration::BitmapPtr bitmap);
/**
* @brief Triggers the previously stored callback function
void TriggerTimer();
private:
-
- TestPlatformAbstraction( const TestPlatformAbstraction& ); ///< Undefined
- TestPlatformAbstraction& operator=( const TestPlatformAbstraction& ); ///< Undefined
+ TestPlatformAbstraction(const TestPlatformAbstraction&); ///< Undefined
+ TestPlatformAbstraction& operator=(const TestPlatformAbstraction&); ///< Undefined
private:
-
struct LoadFileResult
{
inline LoadFileResult()
: loadResult(false)
{
-
}
- bool loadResult;
- Dali::Vector< unsigned char> buffer;
+ bool loadResult;
+ Dali::Vector<unsigned char> buffer;
};
- mutable TraceCallStack mTrace;
- bool mIsLoadingResult;
- ImageDimensions mClosestSize;
+ mutable TraceCallStack mTrace;
+ bool mIsLoadingResult;
+ ImageDimensions mClosestSize;
- LoadFileResult mLoadFileResult;
- bool mSaveFileResult;
+ LoadFileResult mLoadFileResult;
+ bool mSaveFileResult;
- Integration::ResourcePointer mSynchronouslyLoadedResource;
- Integration::BitmapPtr mDecodedBitmap;
+ Integration::ResourcePointer mSynchronouslyLoadedResource;
+ Integration::BitmapPtr mDecodedBitmap;
- uint32_t mTimerId;
- CallbackBase* mCallbackFunction;
+ uint32_t mTimerId;
+ CallbackBase* mCallbackFunction;
};
-} // Dali
+} // namespace Dali
#endif /* DALI_TEST_PLATFORM_ABSTRACTION_H */
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
TestRenderController::TestRenderController()
{
Initialize();
{
}
-void TestRenderController::RequestUpdate( bool forceUpdate )
+void TestRenderController::RequestUpdate(bool forceUpdate)
{
mRequestUpdateCalled = true;
}
-void TestRenderController::RequestProcessEventsOnIdle( bool forceProcess )
+void TestRenderController::RequestProcessEventsOnIdle(bool forceProcess)
{
mRequestProcessEventsOnIdleCalled = true;
}
{
switch(func)
{
- case RequestUpdateFunc: return mRequestUpdateCalled;
- case RequestProcessEventsOnIdleFunc: return mRequestProcessEventsOnIdleCalled;
+ case RequestUpdateFunc:
+ return mRequestUpdateCalled;
+ case RequestProcessEventsOnIdleFunc:
+ return mRequestProcessEventsOnIdleCalled;
}
return false;
void TestRenderController::Initialize()
{
- mRequestUpdateCalled = false;
+ mRequestUpdateCalled = false;
mRequestProcessEventsOnIdleCalled = false;
}
-
-} // namespace dali
+} // namespace Dali
#define TEST_RENDER_CONTROLLER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/integration-api/render-controller.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
class DALI_CORE_API TestRenderController : public Dali::Integration::RenderController
{
public:
TestRenderController();
- ~TestRenderController();
+ ~TestRenderController() override;
- virtual void RequestUpdate( bool forceUpdate );
- virtual void RequestProcessEventsOnIdle( bool forceProcess );
+ void RequestUpdate(bool forceUpdate) override;
+ void RequestProcessEventsOnIdle(bool forceProcess) override;
typedef enum
{
bool WasCalled(TestRenderControllerFuncEnum func);
void Initialize();
-
private:
bool mRequestUpdateCalled;
bool mRequestProcessEventsOnIdleCalled;
};
-} // Dali
+} // namespace Dali
#endif // TEST_RENDER_CONTROLLER_H
*/
struct TouchEventFunctorConsumeSetter
{
- TouchEventFunctorConsumeSetter( bool& consume )
- : mConsume( consume )
+ TouchEventFunctorConsumeSetter(bool& consume)
+ : mConsume(consume)
{
}
};
#endif // TEST_TOUCH_EVENT_UTILS_H
-
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 "test-trace-call-stack.h"
+
#include <sstream>
namespace Dali
{
-
std::string ToString(int x)
{
std::stringstream out;
/**
* Constructor
*/
-TraceCallStack::TraceCallStack() : mTraceActive(false) { }
+TraceCallStack::TraceCallStack()
+: mTraceActive(false)
+{
+}
/**
* Destructor
*/
-TraceCallStack::~TraceCallStack() { }
+TraceCallStack::~TraceCallStack()
+{
+}
/**
* Turn on / off tracing
*/
-void TraceCallStack::Enable(bool enable) { mTraceActive = enable; }
+void TraceCallStack::Enable(bool enable)
+{
+ mTraceActive = enable;
+}
-bool TraceCallStack::IsEnabled() { return mTraceActive; }
+bool TraceCallStack::IsEnabled()
+{
+ return mTraceActive;
+}
/**
* Push a call onto the stack if the trace is active
if(mTraceActive)
{
FunctionCall stackFrame(method, params);
- mCallStack.push_back( stackFrame );
+ mCallStack.push_back(stackFrame);
}
}
if(mTraceActive)
{
FunctionCall stackFrame(method, params, altParams);
- mCallStack.push_back( stackFrame );
+ mCallStack.push_back(stackFrame);
}
}
bool TraceCallStack::FindMethod(std::string method) const
{
bool found = false;
- for( size_t i=0; i < mCallStack.size(); i++ )
+ for(size_t i = 0; i < mCallStack.size(); i++)
{
- if( 0 == mCallStack[i].method.compare(method) )
+ if(0 == mCallStack[i].method.compare(method))
{
found = true;
break;
return found;
}
-bool TraceCallStack::FindMethodAndGetParameters(std::string method, std::string& params ) const
+bool TraceCallStack::FindMethodAndGetParameters(std::string method, std::string& params) const
{
bool found = false;
- for( size_t i=0; i < mCallStack.size(); i++ )
+ for(size_t i = 0; i < mCallStack.size(); i++)
{
- if( 0 == mCallStack[i].method.compare(method) )
+ if(0 == mCallStack[i].method.compare(method))
{
- found = true;
+ found = true;
params = mCallStack[i].paramList;
break;
}
int TraceCallStack::CountMethod(std::string method) const
{
int numCalls = 0;
- for( size_t i=0; i < mCallStack.size(); i++ )
+ for(size_t i = 0; i < mCallStack.size(); i++)
{
- if( 0 == mCallStack[i].method.compare(method) )
+ if(0 == mCallStack[i].method.compare(method))
{
numCalls++;
}
*/
bool TraceCallStack::FindMethodAndParams(std::string method, std::string params) const
{
- return FindIndexFromMethodAndParams( method, params ) > -1;
+ return FindIndexFromMethodAndParams(method, params) > -1;
}
bool TraceCallStack::FindMethodAndParams(std::string method, const NamedParams& params) const
{
- return FindIndexFromMethodAndParams( method, params ) > -1;
+ return FindIndexFromMethodAndParams(method, params) > -1;
}
-bool TraceCallStack::FindMethodAndParamsFromStartIndex( std::string method, std::string params, size_t& startIndex ) const
+bool TraceCallStack::FindMethodAndParamsFromStartIndex(std::string method, std::string params, size_t& startIndex) const
{
- for( size_t i = startIndex; i < mCallStack.size(); ++i )
+ for(size_t i = startIndex; i < mCallStack.size(); ++i)
{
- if( ( mCallStack[i].method.compare( method ) == 0 ) && ( mCallStack[i].paramList.compare( params ) == 0 ) )
+ if((mCallStack[i].method.compare(method) == 0) && (mCallStack[i].paramList.compare(params) == 0))
{
startIndex = i;
return true;
int32_t TraceCallStack::FindIndexFromMethodAndParams(std::string method, std::string params) const
{
int32_t index = -1;
- for( size_t i=0; i < mCallStack.size(); i++ )
+ for(size_t i = 0; i < mCallStack.size(); i++)
{
- if( 0 == mCallStack[i].method.compare(method) && 0 == mCallStack[i].paramList.compare(params) )
+ if(0 == mCallStack[i].method.compare(method) && 0 == mCallStack[i].paramList.compare(params))
{
- index = static_cast<int32_t>( i );
+ index = static_cast<int32_t>(i);
break;
}
}
int TraceCallStack::FindIndexFromMethodAndParams(std::string method, const TraceCallStack::NamedParams& params) const
{
int32_t index = -1;
- for( size_t i=0; i < mCallStack.size(); i++ )
+ for(size_t i = 0; i < mCallStack.size(); i++)
{
- if( 0 == mCallStack[i].method.compare(method) )
+ if(0 == mCallStack[i].method.compare(method))
{
// Test each of the passed in parameters:
bool match = true;
- for( NamedParams::const_iterator iter = params.begin() ; iter != params.end() ; ++iter )
+ for(NamedParams::const_iterator iter = params.begin(); iter != params.end(); ++iter)
{
NamedParams::const_iterator paramIter = mCallStack[i].namedParams.find(iter->first);
- if( paramIter == params.end() || paramIter->second.compare(iter->second) != 0 )
+ if(paramIter == params.end() || paramIter->second.compare(iter->second) != 0)
{
match = false;
break;
}
}
- if( match == true )
+ if(match == true)
{
- index = static_cast<int32_t>( i );
+ index = static_cast<int32_t>(i);
break;
}
}
return index;
}
-
/**
* Test if the given method and parameters are at a given index in the stack
* @param[in] index Index in the call stack
*/
bool TraceCallStack::TestMethodAndParams(int index, std::string method, std::string params) const
{
- return ( 0 == mCallStack[index].method.compare(method) && 0 == mCallStack[index].paramList.compare(params) );
+ return (0 == mCallStack[index].method.compare(method) && 0 == mCallStack[index].paramList.compare(params));
}
/**
mCallStack.clear();
}
-
} // namespace Dali
#define TEST_TRACE_CALL_STACK_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <string>
-#include <vector>
#include <map>
#include <sstream>
+#include <string>
+#include <vector>
namespace Dali
{
-
template<typename T>
std::string ToString(const T& x)
{
class TraceCallStack
{
public:
-
/// Typedef for passing and storing named parameters
- typedef std::map< std::string, std::string > NamedParams;
+ typedef std::map<std::string, std::string> NamedParams;
/**
* Constructor
* @param[out] params of the method
* @return true if the method was in the stack
*/
- bool FindMethodAndGetParameters(std::string method, std::string& params ) const;
+ bool FindMethodAndGetParameters(std::string method, std::string& params) const;
/**
* Count how many times a method was called
* calls can search for methods occuring after this one.
* @return True if the method was in the stack
*/
- bool FindMethodAndParamsFromStartIndex( std::string method, std::string params, size_t& startIndex ) const;
+ bool FindMethodAndParamsFromStartIndex(std::string method, std::string params, size_t& startIndex) const;
/**
* Search for a method in the stack with the given parameter list
std::string GetTraceString()
{
std::stringstream traceStream;
- std::size_t functionCount = mCallStack.size();
- for( std::size_t i = 0; i < functionCount; ++i )
+ std::size_t functionCount = mCallStack.size();
+ for(std::size_t i = 0; i < functionCount; ++i)
{
- Dali::TraceCallStack::FunctionCall functionCall = mCallStack[ i ];
+ Dali::TraceCallStack::FunctionCall functionCall = mCallStack[i];
traceStream << "StackTrace: Index:" << i << ", Function:" << functionCall.method << ", ParamList:" << functionCall.paramList << std::endl;
}
std::string method;
std::string paramList;
NamedParams namedParams;
- FunctionCall( const std::string& aMethod, const std::string& aParamList )
- : method( aMethod ), paramList( aParamList )
+ FunctionCall(const std::string& aMethod, const std::string& aParamList)
+ : method(aMethod),
+ paramList(aParamList)
{
}
- FunctionCall( const std::string& aMethod, const std::string& aParamList, const NamedParams& altParams )
- : method( aMethod ), paramList( aParamList ), namedParams( altParams )
+ FunctionCall(const std::string& aMethod, const std::string& aParamList, const NamedParams& altParams)
+ : method(aMethod),
+ paramList(aParamList),
+ namedParams(altParams)
{
}
};
- std::vector< FunctionCall > mCallStack; ///< The call stack
+ std::vector<FunctionCall> mCallStack; ///< The call stack
};
-} // namespace dali
+} // namespace Dali
#endif // TEST_TRACE_CALL_STACK_H
-#include <string.h>
#include <getopt.h>
#include <stdlib.h>
+#include <string.h>
#include <test-harness.h>
+
#include "tct-dali-core.h"
-int main(int argc, char * const argv[])
+int main(int argc, char* const argv[])
{
int result = TestHarness::EXIT_STATUS_BAD_ARGUMENT;
const char* optString = "sf";
- bool optRerunFailed(true);
- bool optRunSerially(false);
+ bool optRerunFailed(true);
+ bool optRunSerially(false);
int nextOpt = 0;
do
{
- nextOpt = getopt( argc, argv, optString );
+ nextOpt = getopt(argc, argv, optString);
switch(nextOpt)
{
case 'f':
exit(TestHarness::EXIT_STATUS_BAD_ARGUMENT);
break;
}
- } while( nextOpt != -1 );
+ } while(nextOpt != -1);
- if( optind == argc ) // no testcase name in argument list
+ if(optind == argc) // no testcase name in argument list
{
- if( optRunSerially )
+ if(optRunSerially)
{
- result = TestHarness::RunAll( argv[0], tc_array );
+ result = TestHarness::RunAll(argv[0], tc_array);
}
else
{
- result = TestHarness::RunAllInParallel( argv[0], tc_array, optRerunFailed );
+ result = TestHarness::RunAllInParallel(argv[0], tc_array, optRerunFailed);
}
}
else
*
*/
-#include <cstring>
-#include <dali/devel-api/addons/addon-base.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/addons/addon-base.h>
+
+#include <cstring>
static const std::string DUMMY_ADDON_NAME = "SampleAddOn";
-int StringLen( const char* str )
+int StringLen(const char* str)
{
- return strlen( str );
+ return strlen(str);
}
-int DoSum( int a, int b )
+int DoSum(int a, int b)
{
- return a+b;
+ return a + b;
}
class TestDummyAddOn : public Dali::AddOns::AddOnBase
{
public:
-
- void GetAddOnInfo( Dali::AddOnInfo& info ) override
+ void GetAddOnInfo(Dali::AddOnInfo& info) override
{
- info.type = Dali::AddOnType::GENERIC;
- info.name = "SampleAddOn";
- info.version = Dali::DALI_ADDON_VERSION( 1, 0, 0 );
- info.next = nullptr;
- tet_printf( "SampleAddOn: GetAddOnInfo() : name = %s\n", info.name.c_str());
+ info.type = Dali::AddOnType::GENERIC;
+ info.name = "SampleAddOn";
+ info.version = Dali::DALI_ADDON_VERSION(1, 0, 0);
+ info.next = nullptr;
+ tet_printf("SampleAddOn: GetAddOnInfo() : name = %s\n", info.name.c_str());
}
/**
Dali::AddOns::DispatchTable* GetGlobalDispatchTable() override
{
static Dali::AddOns::DispatchTable dispatchTable{};
- if( dispatchTable.Empty() )
+ if(dispatchTable.Empty())
{
- dispatchTable["DoSum"] = DoSum;
- dispatchTable["StringLen"] = StringLen;
+ dispatchTable["DoSum"] = DoSum;
+ dispatchTable["StringLen"] = StringLen;
}
return &dispatchTable;
}
}
};
-REGISTER_ADDON_CLASS( TestDummyAddOn );
+REGISTER_ADDON_CLASS(TestDummyAddOn);
// Enable debug log for test coverage
#define DEBUG_ENABLED 1
-#include "assert.h"
-#include <dali/public-api/dali-core.h>
-#include <string>
-#include <cfloat> // For FLT_MAX
+#include <dali-test-suite-utils.h>
#include <dali/devel-api/actors/actor-devel.h>
-#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/events/hover-event-integ.h>
#include <dali/integration-api/debug.h>
-#include <dali-test-suite-utils.h>
+#include <dali/integration-api/events/hover-event-integ.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/public-api/dali-core.h>
#include <mesh-builder.h>
+#include <cfloat> // For FLT_MAX
+#include <string>
+
+#include "assert.h"
+
//& set: DaliActor
using std::string;
using namespace Dali;
-
void utc_dali_actor_startup(void)
{
test_return_value = TET_UNDEF;
namespace
{
-bool gTouchCallBackCalled=false;
-bool gTouchCallBackCalled2=false;
-bool gTouchCallBackCalled3=false;
+bool gTouchCallBackCalled = false;
+bool gTouchCallBackCalled2 = false;
+bool gTouchCallBackCalled3 = false;
-bool gHoverCallBackCalled=false;
+bool gHoverCallBackCalled = false;
static bool gTestConstraintCalled;
struct TestConstraint
{
- void operator()( Vector4& color, const PropertyInputContainer& /* inputs */ )
+ void operator()(Vector4& color, const PropertyInputContainer& /* inputs */)
{
gTestConstraintCalled = true;
}
{
}
- void operator()( T& current, const PropertyInputContainer& /* inputs */ )
+ void operator()(T& current, const PropertyInputContainer& /* inputs */)
{
mResultRef = mValue;
}
unsigned int& mResultRef;
- unsigned int mValue;
+ unsigned int mValue;
};
-
static bool TestTouchCallback(Actor, const TouchEvent&)
{
gTouchCallBackCalled = true;
static void ResetTouchCallbacks()
{
- gTouchCallBackCalled = false;
+ gTouchCallBackCalled = false;
gTouchCallBackCalled2 = false;
gTouchCallBackCalled3 = false;
}
}
// validation stuff for onstage & offstage signals
-static std::vector< std::string > gActorNamesOnOffScene;
-static int gOnSceneCallBackCalled;
-void OnSceneCallback( Actor actor )
+static std::vector<std::string> gActorNamesOnOffScene;
+static int gOnSceneCallBackCalled;
+void OnSceneCallback(Actor actor)
{
++gOnSceneCallBackCalled;
- gActorNamesOnOffScene.push_back( actor.GetProperty< std::string >( Actor::Property::NAME ) );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) == true );
+ gActorNamesOnOffScene.push_back(actor.GetProperty<std::string>(Actor::Property::NAME));
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE) == true);
}
static int gOffSceneCallBackCalled;
-void OffSceneCallback( Actor actor )
+void OffSceneCallback(Actor actor)
{
++gOffSceneCallBackCalled;
- gActorNamesOnOffScene.push_back( actor.GetProperty< std::string >( Actor::Property::NAME ) );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) == false );
+ gActorNamesOnOffScene.push_back(actor.GetProperty<std::string>(Actor::Property::NAME));
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE) == false);
}
struct PositionComponentConstraint
{
- PositionComponentConstraint(){}
+ PositionComponentConstraint()
+ {
+ }
- void operator()( Vector3& pos, const PropertyInputContainer& inputs )
+ void operator()(Vector3& pos, const PropertyInputContainer& inputs)
{
const Matrix& m = inputs[0]->GetMatrix();
- Vector3 scale;
- Quaternion rot;
+ Vector3 scale;
+ Quaternion rot;
m.GetTransformComponents(pos, rot, scale);
}
};
struct OrientationComponentConstraint
{
- OrientationComponentConstraint(){}
+ OrientationComponentConstraint()
+ {
+ }
- void operator()( Quaternion& orientation, const PropertyInputContainer& inputs )
+ void operator()(Quaternion& orientation, const PropertyInputContainer& inputs)
{
const Quaternion& parentOrientation = inputs[0]->GetQuaternion();
- Vector3 pos, scale;
- Quaternion rot;
+ Vector3 pos, scale;
+ Quaternion rot;
orientation = parentOrientation;
}
};
// OnRelayout
-static bool gOnRelayoutCallBackCalled = false;
-static std::vector< std::string > gActorNamesRelayout;
+static bool gOnRelayoutCallBackCalled = false;
+static std::vector<std::string> gActorNamesRelayout;
-void OnRelayoutCallback( Actor actor )
+void OnRelayoutCallback(Actor actor)
{
gOnRelayoutCallBackCalled = true;
- gActorNamesRelayout.push_back( actor.GetProperty< std::string >( Actor::Property::NAME ) );
+ gActorNamesRelayout.push_back(actor.GetProperty<std::string>(Actor::Property::NAME));
}
struct VisibilityChangedFunctorData
{
VisibilityChangedFunctorData()
: actor(),
- visible( false ),
- type( DevelActor::VisibilityChange::SELF ),
- called( false )
+ visible(false),
+ type(DevelActor::VisibilityChange::SELF),
+ called(false)
{
}
{
actor.Reset();
visible = false;
- type = DevelActor::VisibilityChange::SELF;
- called = false;
+ type = DevelActor::VisibilityChange::SELF;
+ called = false;
}
- void Check( bool compareCalled, Actor compareActor, bool compareVisible, DevelActor::VisibilityChange::Type compareType, const char * location )
+ void Check(bool compareCalled, Actor compareActor, bool compareVisible, DevelActor::VisibilityChange::Type compareType, const char* location)
{
- DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) );
- DALI_TEST_EQUALS( actor, compareActor, TEST_INNER_LOCATION( location ) );
- DALI_TEST_EQUALS( visible, compareVisible, TEST_INNER_LOCATION( location ) );
- DALI_TEST_EQUALS( (int)type, (int)compareType, TEST_INNER_LOCATION( location ) );
+ DALI_TEST_EQUALS(called, compareCalled, TEST_INNER_LOCATION(location));
+ DALI_TEST_EQUALS(actor, compareActor, TEST_INNER_LOCATION(location));
+ DALI_TEST_EQUALS(visible, compareVisible, TEST_INNER_LOCATION(location));
+ DALI_TEST_EQUALS((int)type, (int)compareType, TEST_INNER_LOCATION(location));
}
- void Check( bool compareCalled, const std::string& location )
+ void Check(bool compareCalled, const std::string& location)
{
- DALI_TEST_EQUALS( called, compareCalled, TEST_INNER_LOCATION( location ) );
+ DALI_TEST_EQUALS(called, compareCalled, TEST_INNER_LOCATION(location));
}
- Actor actor;
- bool visible;
+ Actor actor;
+ bool visible;
DevelActor::VisibilityChange::Type type;
- bool called;
+ bool called;
};
struct VisibilityChangedFunctor
{
- VisibilityChangedFunctor( VisibilityChangedFunctorData& dataVar ) : data( dataVar ) { }
+ VisibilityChangedFunctor(VisibilityChangedFunctorData& dataVar)
+ : data(dataVar)
+ {
+ }
- void operator()( Actor actor, bool visible, DevelActor::VisibilityChange::Type type )
+ void operator()(Actor actor, bool visible, DevelActor::VisibilityChange::Type type)
{
- data.actor = actor;
+ data.actor = actor;
data.visible = visible;
- data.type = type;
- data.called = true;
+ data.type = type;
+ data.called = true;
}
VisibilityChangedFunctorData& data;
};
-
struct VisibilityChangedVoidFunctor
{
VisibilityChangedVoidFunctor(bool& signalCalled)
- : mSignalCalled( signalCalled )
- { }
+ : mSignalCalled(signalCalled)
+ {
+ }
void operator()()
{
- mSignalCalled = true;
+ mSignalCalled = true;
}
bool& mSignalCalled;
struct ChildOrderChangedFunctor
{
ChildOrderChangedFunctor(bool& signalCalled, Actor& actor)
- : mSignalCalled( signalCalled ),
- mActor( actor )
- { }
+ : mSignalCalled(signalCalled),
+ mActor(actor)
+ {
+ }
- void operator()( Actor actor )
+ void operator()(Actor actor)
{
- mSignalCalled = true;
- mActor = actor;
+ mSignalCalled = true;
+ mActor = actor;
}
- bool& mSignalCalled;
+ bool& mSignalCalled;
Actor& mActor;
};
struct CulledPropertyNotificationFunctor
{
- CulledPropertyNotificationFunctor( bool& signalCalled, PropertyNotification& propertyNotification )
- : mSignalCalled( signalCalled ),
- mPropertyNotification( propertyNotification )
- { }
+ CulledPropertyNotificationFunctor(bool& signalCalled, PropertyNotification& propertyNotification)
+ : mSignalCalled(signalCalled),
+ mPropertyNotification(propertyNotification)
+ {
+ }
- void operator()( PropertyNotification& source )
+ void operator()(PropertyNotification& source)
{
- mSignalCalled = true;
+ mSignalCalled = true;
mPropertyNotification = source;
}
- bool& mSignalCalled;
+ bool& mSignalCalled;
PropertyNotification& mPropertyNotification;
};
} // anonymous namespace
-
//& purpose: Testing New API
int UtcDaliActorNew(void)
{
TestApplication application;
tet_infoline("Testing Dali::Actor::DownCast()");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
BaseHandle object(actor);
- Actor actor2 = Actor::DownCast(object);
+ Actor actor2 = Actor::DownCast(object);
DALI_TEST_CHECK(actor2);
END_TEST;
}
tet_infoline("Testing Dali::Actor::DownCast()");
BaseHandle unInitializedObject;
- Actor actor = Actor::DownCast(unInitializedObject);
+ Actor actor = Actor::DownCast(unInitializedObject);
DALI_TEST_CHECK(!actor);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- int id = actor.GetProperty< int >( Actor::Property::ID );
+ int id = actor.GetProperty<int>(Actor::Property::ID);
- Actor moved = std::move( actor);
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( id, moved.GetProperty< int >( Actor::Property::ID ), TEST_LOCATION );
- DALI_TEST_CHECK( !actor );
+ Actor moved = std::move(actor);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
+ DALI_TEST_CHECK(!actor);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- int id = actor.GetProperty< int >( Actor::Property::ID );
+ int id = actor.GetProperty<int>(Actor::Property::ID);
Actor moved;
- moved = std::move( actor);
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( id, moved.GetProperty< int >( Actor::Property::ID ), TEST_LOCATION );
- DALI_TEST_CHECK( !actor );
+ moved = std::move(actor);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
+ DALI_TEST_CHECK(!actor);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_CHECK(actor.GetProperty< std::string >( Actor::Property::NAME ).empty());
+ DALI_TEST_CHECK(actor.GetProperty<std::string>(Actor::Property::NAME).empty());
END_TEST;
}
TestApplication application;
string str("ActorName");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::NAME,str);
- DALI_TEST_CHECK(actor.GetProperty< std::string >( Actor::Property::NAME ) == str);
+ actor.SetProperty(Actor::Property::NAME, str);
+ DALI_TEST_CHECK(actor.GetProperty<std::string>(Actor::Property::NAME) == str);
END_TEST;
}
tet_infoline("Testing Dali::Actor::UtcDaliActo.GetProperty< int >( Actor::Property::ID )");
TestApplication application;
- Actor first = Actor::New();
+ Actor first = Actor::New();
Actor second = Actor::New();
- Actor third = Actor::New();
+ Actor third = Actor::New();
- DALI_TEST_CHECK(first.GetProperty< int >( Actor::Property::ID ) != second.GetProperty< int >( Actor::Property::ID ));
- DALI_TEST_CHECK(second.GetProperty< int >( Actor::Property::ID ) != third.GetProperty< int >( Actor::Property::ID ));
+ DALI_TEST_CHECK(first.GetProperty<int>(Actor::Property::ID) != second.GetProperty<int>(Actor::Property::ID));
+ DALI_TEST_CHECK(second.GetProperty<int>(Actor::Property::ID) != third.GetProperty<int>(Actor::Property::ID));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK(!actor.GetProperty< bool >( Actor::Property::IS_ROOT ));
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::IS_ROOT));
// get the root layer
- actor = application.GetScene().GetLayer( 0 );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::IS_ROOT ) );
+ actor = application.GetScene().GetLayer(0);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::IS_ROOT));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
// get the root layer
- actor = application.GetScene().GetLayer( 0 );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ actor = application.GetScene().GetLayer(0);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::IS_LAYER ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::IS_LAYER));
// get the root layer
- actor = application.GetScene().GetLayer( 0 );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::IS_LAYER ) );
+ actor = application.GetScene().GetLayer(0);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::IS_LAYER));
END_TEST;
}
DALI_TEST_CHECK(layer);
// get the root layers layer
- actor = application.GetScene().GetLayer( 0 );
- DALI_TEST_CHECK( actor.GetLayer() );
+ actor = application.GetScene().GetLayer(0);
+ DALI_TEST_CHECK(actor.GetLayer());
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- Actor child = Actor::New();
+ Actor child = Actor::New();
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
parent.Add(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
Actor parent2 = Actor::New();
- parent2.Add( child );
+ parent2.Add(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
// try Adding to same parent again, works
- parent2.Add( child );
- DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
+ parent2.Add(child);
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
// try reparenting an orphaned child
{
Actor temporaryParent = Actor::New();
- temporaryParent.Add( child );
- DALI_TEST_EQUALS( parent2.GetChildCount(), 0u, TEST_LOCATION );
+ temporaryParent.Add(child);
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 0u, TEST_LOCATION);
}
// temporaryParent has now died, reparent the orphaned child
- parent2.Add( child );
- DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
+ parent2.Add(child);
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
END_TEST;
}
Actor child = Actor::New();
Actor parent2 = Actor::New();
- parent2.Add( child );
+ parent2.Add(child);
// try illegal Add
try
{
- parent2.Add( parent2 );
- tet_printf("Assertion test failed - no Exception\n" );
+ parent2.Add(parent2);
+ tet_printf("Assertion test failed - no Exception\n");
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "this != &child", TEST_LOCATION);
- DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
// try reparenting root
try
{
- parent2.Add( application.GetScene().GetLayer( 0 ) );
- tet_printf("Assertion test failed - no Exception\n" );
+ parent2.Add(application.GetScene().GetLayer(0));
+ tet_printf("Assertion test failed - no Exception\n");
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "!child.IsRoot()", TEST_LOCATION);
- DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
Actor empty;
- parent2.Add( empty );
- tet_printf("Assertion test failed - no Exception\n" );
+ parent2.Add(empty);
+ tet_printf("Assertion test failed - no Exception\n");
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
- DALI_TEST_EQUALS( parent2.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent2.GetChildCount(), 1u, TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
TestApplication application;
Actor parent = Actor::New();
- Actor child = Actor::New();
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
+ Actor child = Actor::New();
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
parent.Add(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
parent.Remove(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
// remove again, no problem
parent.Remove(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
// add child back
parent.Add(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
// try Remove self, its a no-op
- parent.Remove( parent );
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
+ parent.Remove(parent);
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
// try Remove empty
try
{
Actor empty;
- parent.Remove( empty );
- tet_printf("Assertion test failed - no Exception\n" );
+ parent.Remove(empty);
+ tet_printf("Assertion test failed - no Exception\n");
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
END_TEST;
TestApplication application;
Actor parent = Actor::New();
- Actor child = Actor::New();
+ Actor child = Actor::New();
Actor random = Actor::New();
- application.GetScene().Add( parent );
+ application.GetScene().Add(parent);
DALI_TEST_CHECK(parent.GetChildCount() == 0);
DALI_TEST_CHECK(parent.GetChildCount() == 1);
- application.GetScene().Remove( parent );
+ application.GetScene().Remove(parent);
DALI_TEST_CHECK(parent.GetChildCount() == 1);
END_TEST;
TestApplication application;
Actor parent = Actor::New();
- Actor child = Actor::New();
+ Actor child = Actor::New();
DALI_TEST_CHECK(parent.GetChildCount() == 0);
TestApplication application;
Actor parent = Actor::New();
- Actor child = Actor::New();
+ Actor child = Actor::New();
parent.Add(child);
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- float startValue(1.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+ float startValue(1.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
- actor.SetProperty( index, 5.0f );
+ actor.SetProperty(index, 5.0f);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( actor.GetProperty<float>(index) == 5.0f );
+ DALI_TEST_CHECK(actor.GetProperty<float>(index) == 5.0f);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- float startValue(5.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+ float startValue(5.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( actor.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<float>(index) == startValue);
- actor.SetProperty( index, int(1) );
+ actor.SetProperty(index, int(1));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( actor.GetProperty<float>(index) == 1.0f );
+ DALI_TEST_CHECK(actor.GetProperty<float>(index) == 1.0f);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- int startValue(5);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
+ int startValue(5);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(actor.GetProperty<int>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( actor.GetProperty<int>(index) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<int>(index) == startValue);
- actor.SetProperty( index, float(1.5) );
+ actor.SetProperty(index, float(1.5));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( actor.GetProperty<int>(index) == 1 );
+ DALI_TEST_CHECK(actor.GetProperty<int>(index) == 1);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, vector );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.1f, 0.2f, 0.3f ) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.1f, 0.2f, 0.3f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
- actor.SetProperty( Actor::Property::PARENT_ORIGIN_X, vector.x );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN_X, vector.x);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).x, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).x, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN_Y, vector.y );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN_Y, vector.y);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).y, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).y, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN_Z, vector.z );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN_Z, vector.z);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).z, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).z, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, vector );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN));
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
- actor.SetProperty( Actor::Property::ANCHOR_POINT, vector );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, Vector3( 0.1f, 0.2f, 0.3f ) );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, Vector3(0.1f, 0.2f, 0.3f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
- actor.SetProperty( Actor::Property::ANCHOR_POINT_X, vector.x );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT_X, vector.x);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).x, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).x, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT_Y, vector.y );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT_Y, vector.y);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).y, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).y, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT_Z, vector.z );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT_Z, vector.z);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).z, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).z, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
- actor.SetProperty( Actor::Property::ANCHOR_POINT, vector);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT));
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 0.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE, Vector2( vector.x, vector.y ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(vector.x, vector.y));
// Immediately retrieve the size after setting
- Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
// Flush the queue and render once
application.SendNotification();
application.Render();
// Check the size in the new frame
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
// Check async behaviour
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
// Change the resize policy and check whether the size stays the same
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// Set a new size after resize policy is changed and check the new size
- actor.SetProperty( Actor::Property::SIZE, Vector3( 0.1f, 0.2f, 0.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector3(0.1f, 0.2f, 0.0f));
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.0f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
// Change the resize policy again and check whether the new size stays the same
- actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
+ actor.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.0f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
// Set another new size after resize policy is changed and check the new size
- actor.SetProperty( Actor::Property::SIZE, Vector3( 50.0f, 60.0f, 0.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector3(50.0f, 60.0f, 0.0f));
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, Vector3( 50.0f, 60.0f, 0.0f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, Vector3(50.0f, 60.0f, 0.0f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE, Vector3( vector.x, vector.y, vector.z ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector3(vector.x, vector.y, vector.z));
// Immediately check the size after setting
- Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the size in the new frame
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 0.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE,Vector2(vector.x, vector.y));
+ actor.SetProperty(Actor::Property::SIZE, Vector2(vector.x, vector.y));
// Immediately check the size after setting
- Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the size in the new frame
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE,vector);
+ actor.SetProperty(Actor::Property::SIZE, vector);
// Immediately check the size after setting
- Vector3 currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ Vector3 currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, vector, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the size in the new frame
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- application.GetScene().Add( actor );
- actor.SetProperty( Actor::Property::SIZE, Vector3( 0.1f, 0.2f, 0.3f ) );
+ application.GetScene().Add(actor);
+ actor.SetProperty(Actor::Property::SIZE, Vector3(0.1f, 0.2f, 0.3f));
// Immediately check the size after setting
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.3f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the size in the new frame
- DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), TEST_LOCATION);
- currentSize = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, Vector3( 0.1f, 0.2f, 0.3f ), Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, Vector3(0.1f, 0.2f, 0.3f), Math::MACHINE_EPSILON_0, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
+ actor.SetProperty(Actor::Property::SIZE_WIDTH, vector.width);
// Immediately check the width after setting
- float sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
- DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ float sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
+ DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the width in the new frame
- DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.width, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, TEST_LOCATION);
- sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
- DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
+ DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
+ actor.SetProperty(Actor::Property::SIZE_HEIGHT, vector.height);
// Immediately check the height after setting
- float sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
- DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ float sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
+ DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the height in the new frame
- DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.height, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, TEST_LOCATION);
- sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
- DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
+ DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
+ actor.SetProperty(Actor::Property::SIZE_DEPTH, vector.depth);
// Immediately check the depth after setting
- float sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
- DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ float sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
+ DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the depth in the new frame
- DALI_TEST_EQUALS( vector.depth, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).depth, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.depth, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).depth, TEST_LOCATION);
- sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
- DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
+ DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// Change the resize policy and check whether the size stays the same
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
- sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
- DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
+ DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
- DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
+ DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
- DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
+ DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// Change the resize policy again and check whether the size stays the same
- actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
+ actor.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
- sizeWidth = actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >();
- DALI_TEST_EQUALS( sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeWidth = actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>();
+ DALI_TEST_EQUALS(sizeWidth, vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- sizeHeight = actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >();
- DALI_TEST_EQUALS( sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeHeight = actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>();
+ DALI_TEST_EQUALS(sizeHeight, vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- sizeDepth = actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >();
- DALI_TEST_EQUALS( sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ sizeDepth = actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>();
+ DALI_TEST_EQUALS(sizeDepth, vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- application.GetScene().Add( actor );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(actor);
- Vector3 vector( 100.0f, 200.0f, 400.0f );
- DALI_TEST_CHECK( vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ) );
+ Vector3 vector(100.0f, 200.0f, 400.0f);
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE_WIDTH, vector.width );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_WIDTH ).Get< float >(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_WIDTH, vector.width);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_WIDTH).Get<float>(), vector.width, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- actor.SetProperty( Actor::Property::SIZE_HEIGHT, vector.height );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_HEIGHT ).Get< float >(), vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_HEIGHT, vector.height);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_HEIGHT).Get<float>(), vector.height, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- actor.SetProperty( Actor::Property::SIZE_DEPTH, vector.depth );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_DEPTH ).Get< float >(), vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_DEPTH, vector.depth);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_DEPTH).Get<float>(), vector.depth, Math::MACHINE_EPSILON_0, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
// Check the width in the new frame
- DALI_TEST_EQUALS( vector.width, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.height, actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.width, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.height, actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliActorGetCurrentSize(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 20.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE,vector);
+ actor.SetProperty(Actor::Property::SIZE, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
- Vector3 vector( 0.0f, 0.0f, 0.0f );
+ Actor actor = Actor::New();
+ Vector3 vector(0.0f, 0.0f, 0.0f);
- DALI_TEST_CHECK( actor.GetNaturalSize() == vector );
+ DALI_TEST_CHECK(actor.GetNaturalSize() == vector);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 20.0f);
DALI_TEST_CHECK(vector != actor.GetTargetSize());
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
- actor.SetProperty( Actor::Property::SIZE,vector);
+ actor.SetProperty(Actor::Property::SIZE, vector);
DALI_TEST_CHECK(vector == actor.GetTargetSize());
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
// flush the queue and render once
application.SendNotification();
application.Render();
DALI_TEST_CHECK(vector == actor.GetTargetSize());
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
// Animation
// Build the animation
- const float durationSeconds = 2.0f;
- Animation animation = Animation::New( durationSeconds );
- const Vector3 targetValue( 10.0f, 20.0f, 30.0f );
- animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue );
+ const float durationSeconds = 2.0f;
+ Animation animation = Animation::New(durationSeconds);
+ const Vector3 targetValue(10.0f, 20.0f, 30.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetValue);
- DALI_TEST_CHECK( actor.GetTargetSize() == vector );
+ DALI_TEST_CHECK(actor.GetTargetSize() == vector);
+
+ application.GetScene().Add(actor);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( static_cast<unsigned int>( durationSeconds * 1000.0f ) );
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f));
- DALI_TEST_CHECK( actor.GetTargetSize() == targetValue );
+ DALI_TEST_CHECK(actor.GetTargetSize() == targetValue);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::POSITION, Vector3(2.0f, 2.0f, 16.0f));
- actor.SetProperty( Actor::Property::SIZE,Vector3{ 1.0f, 1.0f, 1.0f });
+ actor.SetProperty(Actor::Property::POSITION, Vector3(2.0f, 2.0f, 16.0f));
+ actor.SetProperty(Actor::Property::SIZE, Vector3{1.0f, 1.0f, 1.0f});
application.SendNotification();
application.Render();
- auto expectedExtent = Rect<>{ -0.5f, -0.5f, 1.0f, 1.0f };
- auto actualExtent = DevelActor::CalculateScreenExtents( actor );
- DALI_TEST_EQUALS( expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
- DALI_TEST_EQUALS( expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
- DALI_TEST_EQUALS( expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
- DALI_TEST_EQUALS( expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+ auto expectedExtent = Rect<>{-0.5f, -0.5f, 1.0f, 1.0f};
+ auto actualExtent = DevelActor::CalculateScreenExtents(actor);
+ DALI_TEST_EQUALS(expectedExtent.x, actualExtent.x, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.y, actualExtent.y, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.width, actualExtent.width, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(expectedExtent.height, actualExtent.height, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
// Set to random to start off with
- actor.SetProperty( Actor::Property::POSITION, Vector3(120.0f, 120.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(120.0f, 120.0f, 0.0f));
Vector3 vector(100.0f, 100.0f, 0.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION, Vector2(vector.x, vector.y));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(vector.x, vector.y));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- application.GetScene().Add( actor );
- actor.SetProperty( Actor::Property::POSITION, Vector3( 0.1f, 0.2f, 0.3f ) );
+ application.GetScene().Add(actor);
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.1f, 0.2f, 0.3f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION_X, 1.0f );
- actor.SetProperty( Actor::Property::POSITION_Y, 1.1f );
- actor.SetProperty( Actor::Property::POSITION_Z, 1.2f );
+ actor.SetProperty(Actor::Property::POSITION_X, 1.0f);
+ actor.SetProperty(Actor::Property::POSITION_Y, 1.1f);
+ actor.SetProperty(Actor::Property::POSITION_Z, 1.2f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector3( 1.0f, 1.1f, 1.2f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(1.0f, 1.1f, 1.2f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
- actor.TranslateBy( Vector3( 0.1f, 0.1f, 0.1f ) );
+ actor.TranslateBy(Vector3(0.1f, 0.1f, 0.1f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector3( 1.1f, 1.2f, 1.3f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Math::MACHINE_EPSILON_10000, TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(1.1f, 1.2f, 1.3f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
// Set to random to start off with
- actor.SetProperty( Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
Vector3 vector(100.0f, 100.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION, Vector3(vector.x, vector.y, vector.z));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(vector.x, vector.y, vector.z));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
END_TEST;
}
Actor actor = Actor::New();
// Set to random to start off with
- actor.SetProperty( Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(120.0f, 120.0f, 120.0f));
Vector3 vector(100.0f, 100.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION, vector);
+ actor.SetProperty(Actor::Property::POSITION, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
END_TEST;
}
Vector3 vector(100.0f, 0.0f, 0.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION_X, 100.0f);
+ actor.SetProperty(Actor::Property::POSITION_X, 100.0f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
END_TEST;
}
Vector3 vector(0.0f, 100.0f, 0.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION_Y, 100.0f);
+ actor.SetProperty(Actor::Property::POSITION_Y, 100.0f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
END_TEST;
}
Vector3 vector(0.0f, 0.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION_Z, 100.0f);
+ actor.SetProperty(Actor::Property::POSITION_Z, 100.0f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION_X, vector.x );
- DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::POSITION_X, vector.x);
+ DALI_TEST_EQUALS(vector.x, actor.GetProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::POSITION_X), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::POSITION_X), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION_Y, vector.y );
- DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::POSITION_Y, vector.y);
+ DALI_TEST_EQUALS(vector.y, actor.GetProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::POSITION_Y), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Y ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::POSITION_Y), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<float>(Actor::Property::POSITION_Y), TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION_Z, vector.z );
- DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::POSITION_Z, vector.z);
+ DALI_TEST_EQUALS(vector.z, actor.GetProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::POSITION_Z), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::POSITION_Z ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::POSITION_Z), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<float>(Actor::Property::POSITION_Z), TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 vector(100.0f, 100.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- actor.SetProperty( Actor::Property::POSITION, vector);
+ actor.SetProperty(Actor::Property::POSITION, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
actor.TranslateBy(vector);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector*2.0f == actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
+ DALI_TEST_CHECK(vector * 2.0f == actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 setVector(100.0f, 100.0f, 0.0f);
- actor.SetProperty( Actor::Property::POSITION, setVector);
+ actor.SetProperty(Actor::Property::POSITION, setVector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) == setVector);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION) == setVector);
END_TEST;
}
{
TestApplication application;
- Actor parent = Actor::New();
- Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::POSITION, parentPosition );
- parent.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- parent.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- application.GetScene().Add( parent );
+ Actor parent = Actor::New();
+ Vector3 parentPosition(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::POSITION, parentPosition);
+ parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- child.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- Vector3 childPosition( 6.0f, 6.0f, 6.0f );
- child.SetProperty( Actor::Property::POSITION, childPosition );
- parent.Add( child );
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ Vector3 childPosition(6.0f, 6.0f, 6.0f);
+ child.SetProperty(Actor::Property::POSITION, childPosition);
+ parent.Add(child);
// The actors should not have a world position yet
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childPosition, TEST_LOCATION);
// The actors should have a world position now
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition + childPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition + childPosition, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Actor::SetInheritPosition");
TestApplication application;
- Actor parent = Actor::New();
- Vector3 parentPosition( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::POSITION, parentPosition );
- parent.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- parent.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- application.GetScene().Add( parent );
+ Actor parent = Actor::New();
+ Vector3 parentPosition(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::POSITION, parentPosition);
+ parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- child.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- Vector3 childPosition( 10.0f, 11.0f, 12.0f );
- child.SetProperty( Actor::Property::POSITION, childPosition );
- parent.Add( child );
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ Vector3 childPosition(10.0f, 11.0f, 12.0f);
+ child.SetProperty(Actor::Property::POSITION, childPosition);
+ parent.Add(child);
// The actors should not have a world position yet
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3::ZERO, TEST_LOCATION);
// first test default, which is to inherit position
- DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_POSITION ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_POSITION), true, TEST_LOCATION);
application.SendNotification();
application.Render(0); // should only really call Update as Render is not required to update scene
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition + childPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition + childPosition, TEST_LOCATION);
//Change child position
- Vector3 childOffset( -1.0f, 1.0f, 0.0f );
- child.SetProperty( Actor::Property::POSITION, childOffset );
+ Vector3 childOffset(-1.0f, 1.0f, 0.0f);
+ child.SetProperty(Actor::Property::POSITION, childOffset);
// Use local position as world postion
- child.SetProperty( Actor::Property::INHERIT_POSITION, false );
- DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_POSITION ), false, TEST_LOCATION );
+ child.SetProperty(Actor::Property::INHERIT_POSITION, false);
+ DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_POSITION), false, TEST_LOCATION);
application.SendNotification();
application.Render(0); // should only really call Update as Render is not required to update scene
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childOffset, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), childOffset, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childOffset, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), childOffset, TEST_LOCATION);
//Change back to inherit position from parent
- child.SetProperty( Actor::Property::INHERIT_POSITION, true );
- DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_POSITION ), true, TEST_LOCATION );
+ child.SetProperty(Actor::Property::INHERIT_POSITION, true);
+ DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_POSITION), true, TEST_LOCATION);
application.SendNotification();
application.Render(0); // should only really call Update as Render is not required to update scene
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), childOffset, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), parentPosition + childOffset, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), childOffset, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), parentPosition + childOffset, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- Actor child = Actor::New();
- parent.Add( child );
- application.GetScene().Add( parent );
+ Actor child = Actor::New();
+ parent.Add(child);
+ application.GetScene().Add(parent);
- DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- parent.SetProperty( Actor::Property::OPACITY, 0.1f );
+ parent.SetProperty(Actor::Property::OPACITY, 0.1f);
- DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.0f, 0.0001f, TEST_LOCATION);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( parent.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::WORLD_COLOR ).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty( Actor::Property::COLOR_ALPHA ).Get<float>(), 1.f, 0.0001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetCurrentProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 0.1f, 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetCurrentProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty(Actor::Property::WORLD_COLOR).Get<Vector4>(), Vector4(1.f, 1.f, 1.f, 0.1f), 0.0001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty(Actor::Property::COLOR_ALPHA).Get<float>(), 1.f, 0.0001f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- Actor actor = Actor::New();
+ Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, rotation);
+ actor.SetProperty(Actor::Property::ORIENTATION, rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Radian angle( 0.785f );
+ Radian angle(0.785f);
Vector3 axis(1.0f, 1.0f, 0.0f);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( angle, axis ) );
- Quaternion rotation( angle, axis );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(angle, axis));
+ Quaternion rotation(angle, axis);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
- application.GetScene().Add( actor );
- actor.RotateBy( Degree( 360 ), axis);
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ application.GetScene().Add(actor);
+ actor.RotateBy(Degree(360), axis);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) ) );
- Quaternion result( Radian( 0 ), Vector3( 1.0f, 0.0f, 0.0f ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(0), Vector3(1.0f, 0.0f, 0.0f)));
+ Quaternion result(Radian(0), Vector3(1.0f, 0.0f, 0.0f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(result, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( angle, axis ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(angle, axis));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
{
TestApplication application;
- Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- Actor actor = Actor::New();
+ Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, rotation );
- DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ actor.SetProperty(Actor::Property::ORIENTATION, rotation);
+ DALI_TEST_EQUALS(rotation, actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
- DALI_TEST_EQUALS(rotation, actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Radian angle( M_PI * 0.25f );
- actor.RotateBy(( angle ), Vector3::ZAXIS);
+ Radian angle(M_PI * 0.25f);
+ actor.RotateBy((angle), Vector3::ZAXIS);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(Quaternion( angle, Vector3::ZAXIS), actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Quaternion(angle, Vector3::ZAXIS), actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- actor.RotateBy( angle, Vector3::ZAXIS);
+ actor.RotateBy(angle, Vector3::ZAXIS);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
- Radian angle( M_PI * 0.25f );
+ Radian angle(M_PI * 0.25f);
Quaternion rotation(angle, Vector3::ZAXIS);
actor.RotateBy(rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
actor.RotateBy(rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Quaternion(angle * 2.0f, Vector3::ZAXIS), actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorGetCurrentOrientation(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- actor.SetProperty( Actor::Property::ORIENTATION, rotation );
+ actor.SetProperty(Actor::Property::ORIENTATION, rotation);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(rotation, actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Actor::GetCurrentWorldRotation");
TestApplication application;
- Actor parent = Actor::New();
- Radian rotationAngle( Degree(90.0f) );
- Quaternion rotation( rotationAngle, Vector3::YAXIS );
- parent.SetProperty( Actor::Property::ORIENTATION, rotation );
- application.GetScene().Add( parent );
+ Actor parent = Actor::New();
+ Radian rotationAngle(Degree(90.0f));
+ Quaternion rotation(rotationAngle, Vector3::YAXIS);
+ parent.SetProperty(Actor::Property::ORIENTATION, rotation);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::ORIENTATION, rotation );
- parent.Add( child );
+ child.SetProperty(Actor::Property::ORIENTATION, rotation);
+ parent.Add(child);
// The actors should not have a world rotation yet
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(Radian(0.0f), Vector3::YAXIS), 0.001, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, 0.001, TEST_LOCATION);
// The actors should have a world rotation now
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion( rotationAngle * 2.0f, Vector3::YAXIS ), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(rotationAngle, Vector3::YAXIS), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(rotationAngle * 2.0f, Vector3::YAXIS), 0.001, TEST_LOCATION);
// turn off child rotation inheritance
- child.SetProperty( Actor::Property::INHERIT_ORIENTATION, false );
- DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION ), false, TEST_LOCATION );
+ child.SetProperty(Actor::Property::INHERIT_ORIENTATION, false);
+ DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_ORIENTATION), false, TEST_LOCATION);
application.SendNotification();
application.Render(0);
// The actors should have a world rotation now
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion( rotationAngle, Vector3::YAXIS ), 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), rotation, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion(rotationAngle, Vector3::YAXIS), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), rotation, 0.001, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
- actor.SetProperty( Actor::Property::SCALE,0.25f);
+ actor.SetProperty(Actor::Property::SCALE, 0.25f);
Vector3 scale(10.0f, 10.0f, 10.0f);
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) != scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) != scale);
- actor.SetProperty( Actor::Property::SCALE,scale.x);
+ actor.SetProperty(Actor::Property::SCALE, scale.x);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
END_TEST;
}
int UtcDaliActorSetScale02(void)
{
TestApplication application;
- Vector3 scale(10.0f, 10.0f, 10.0f);
+ Vector3 scale(10.0f, 10.0f, 10.0f);
Actor actor = Actor::New();
// Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
- actor.SetProperty( Actor::Property::SCALE, Vector3( 12.0f, 1.0f, 2.0f ) );
+ actor.SetProperty(Actor::Property::SCALE, Vector3(12.0f, 1.0f, 2.0f));
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) != scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) != scale);
- actor.SetProperty( Actor::Property::SCALE, Vector3( scale.x, scale.y, scale.z ) );
+ actor.SetProperty(Actor::Property::SCALE, Vector3(scale.x, scale.y, scale.z));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
// add to stage and test
- application.GetScene().Add( actor );
- actor.SetProperty( Actor::Property::SCALE, Vector3( 2.0f, 2.0f, 2.0f ) );
+ application.GetScene().Add(actor);
+ actor.SetProperty(Actor::Property::SCALE, Vector3(2.0f, 2.0f, 2.0f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector3( 2.0f, 2.0f, 2.0f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(2.0f, 2.0f, 2.0f), actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), 0.001, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
int UtcDaliActorSetScale03(void)
{
TestApplication application;
- Vector3 scale(10.0f, 10.0f, 10.0f);
+ Vector3 scale(10.0f, 10.0f, 10.0f);
Actor actor = Actor::New();
// Set to random value first -.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) asserts if called before SetScale()
- actor.SetProperty( Actor::Property::SCALE, Vector3(12.0f, 1.0f, 2.0f));
+ actor.SetProperty(Actor::Property::SCALE, Vector3(12.0f, 1.0f, 2.0f));
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) != scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) != scale);
- actor.SetProperty( Actor::Property::SCALE,scale);
+ actor.SetProperty(Actor::Property::SCALE, scale);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
END_TEST;
}
Actor actor = Actor::New();
Vector3 vector(0.7f, 0.8f, 0.9f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
- actor.SetProperty( Actor::Property::SCALE_X, vector.x );
- DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SCALE_X, vector.x);
+ DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::SCALE_X), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).x, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.x, actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).x, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetProperty<float>(Actor::Property::SCALE_X), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.x, actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), TEST_LOCATION);
- actor.SetProperty( Actor::Property::SCALE_Y, vector.y );
- DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SCALE_Y, vector.y);
+ DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::SCALE_Y), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).y, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.y, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).y, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetProperty<float>(Actor::Property::SCALE_Y), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.y, actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), TEST_LOCATION);
- actor.SetProperty( Actor::Property::SCALE_Z, vector.z );
- DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SCALE_Z, vector.z);
+ DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::SCALE_Z), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).z, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.z, actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).z, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetProperty<float>(Actor::Property::SCALE_Z), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.z, actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), TEST_LOCATION);
- DALI_TEST_EQUALS( vector, actor.GetProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector, actor.GetProperty<Vector3>(Actor::Property::SCALE), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector, actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), TEST_LOCATION);
END_TEST;
}
int UtcDaliActorScaleBy(void)
{
TestApplication application;
- Actor actor = Actor::New();
- Vector3 vector(100.0f, 100.0f, 100.0f);
+ Actor actor = Actor::New();
+ Vector3 vector(100.0f, 100.0f, 100.0f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
- actor.SetProperty( Actor::Property::SCALE,vector);
+ actor.SetProperty(Actor::Property::SCALE, vector);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector == actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
+ DALI_TEST_CHECK(vector == actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
actor.ScaleBy(vector);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(vector*100.0f == actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
+ DALI_TEST_CHECK(vector * 100.0f == actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
END_TEST;
}
int UtcDaliActorGetCurrentScale(void)
{
TestApplication application;
- Vector3 scale(12.0f, 1.0f, 2.0f);
+ Vector3 scale(12.0f, 1.0f, 2.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SCALE,scale);
+ actor.SetProperty(Actor::Property::SCALE, scale);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ) == scale);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE) == scale);
END_TEST;
}
{
TestApplication application;
- Actor parent = Actor::New();
- Vector3 parentScale( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::SCALE, parentScale );
- application.GetScene().Add( parent );
+ Actor parent = Actor::New();
+ Vector3 parentScale(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::SCALE, parentScale);
+ application.GetScene().Add(parent);
- Actor child = Actor::New();
- Vector3 childScale( 2.0f, 2.0f, 2.0f );
- child.SetProperty( Actor::Property::SCALE, childScale );
- parent.Add( child );
+ Actor child = Actor::New();
+ Vector3 childScale(2.0f, 2.0f, 2.0f);
+ child.SetProperty(Actor::Property::SCALE, childScale);
+ parent.Add(child);
// The actors should not have a scale yet
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// The actors should not have a world scale yet
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), Vector3::ONE, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), parentScale, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), childScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::SCALE), parentScale, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::SCALE), childScale, TEST_LOCATION);
// The actors should have a world scale now
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), parentScale, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), parentScale * childScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), parentScale, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), parentScale * childScale, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Actor::SetInheritScale");
TestApplication application;
- Actor parent = Actor::New();
- Vector3 parentScale( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::SCALE, parentScale );
- application.GetScene().Add( parent );
+ Actor parent = Actor::New();
+ Vector3 parentScale(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::SCALE, parentScale);
+ application.GetScene().Add(parent);
- Actor child = Actor::New();
- Vector3 childScale( 2.0f, 2.0f, 2.0f );
- child.SetProperty( Actor::Property::SCALE, childScale );
- parent.Add( child );
+ Actor child = Actor::New();
+ Vector3 childScale(2.0f, 2.0f, 2.0f);
+ child.SetProperty(Actor::Property::SCALE, childScale);
+ parent.Add(child);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_SCALE ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), parentScale * childScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_SCALE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), parentScale * childScale, TEST_LOCATION);
- child.SetProperty( Actor::Property::INHERIT_SCALE, false );
- DALI_TEST_EQUALS( child.GetProperty< bool >( Actor::Property::INHERIT_SCALE ), false, TEST_LOCATION );
+ child.SetProperty(Actor::Property::INHERIT_SCALE, false);
+ DALI_TEST_EQUALS(child.GetProperty<bool>(Actor::Property::INHERIT_SCALE), false, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE ), childScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::WORLD_SCALE), childScale, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == false);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == false);
- actor.SetProperty( Actor::Property::VISIBLE,true);
+ actor.SetProperty(Actor::Property::VISIBLE, true);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
// put actor on stage
- application.GetScene().Add( actor );
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ application.GetScene().Add(actor);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == false);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == false);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
END_TEST;
}
Actor actor = Actor::New();
// initial opacity is 1
- DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 1.0f, TEST_LOCATION);
- actor.SetProperty( Actor::Property::OPACITY, 0.4f);
+ actor.SetProperty(Actor::Property::OPACITY, 0.4f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.4f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.4f, TEST_LOCATION);
// change opacity, actor is on stage to change is not immediate
- actor.SetProperty( Actor::Property::OPACITY, actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) + 0.1f );
+ actor.SetProperty(Actor::Property::OPACITY, actor.GetCurrentProperty<float>(Actor::Property::OPACITY) + 0.1f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.5f, TEST_LOCATION);
// put actor on stage
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// change opacity, actor is on stage to change is not immediate
- actor.SetProperty( Actor::Property::OPACITY, 0.9f );
- DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.5f, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::OPACITY, 0.9f);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.5f, TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.9f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.9f, TEST_LOCATION);
// change opacity, actor is on stage to change is not immediate
- actor.SetProperty( Actor::Property::OPACITY, actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) - 0.9f );
+ actor.SetProperty(Actor::Property::OPACITY, actor.GetCurrentProperty<float>(Actor::Property::OPACITY) - 0.9f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.0f, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) != 0.5f);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<float>(Actor::Property::OPACITY) != 0.5f);
- actor.SetProperty( Actor::Property::OPACITY,0.5f);
+ actor.SetProperty(Actor::Property::OPACITY, 0.5f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(actor.GetCurrentProperty< float >( Actor::Property::OPACITY ) == 0.5f);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<float>(Actor::Property::OPACITY) == 0.5f);
END_TEST;
}
int UtcDaliActorSetSensitive(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
- bool sensitive = !actor.GetProperty< bool >( Actor::Property::SENSITIVE );
+ bool sensitive = !actor.GetProperty<bool>(Actor::Property::SENSITIVE);
- actor.SetProperty( Actor::Property::SENSITIVE,sensitive);
+ actor.SetProperty(Actor::Property::SENSITIVE, sensitive);
- DALI_TEST_CHECK(sensitive == actor.GetProperty< bool >( Actor::Property::SENSITIVE ));
+ DALI_TEST_CHECK(sensitive == actor.GetProperty<bool>(Actor::Property::SENSITIVE));
END_TEST;
}
int UtcDaliActorIsSensitive(void)
{
TestApplication application;
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SENSITIVE,false);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SENSITIVE, false);
- DALI_TEST_CHECK(false == actor.GetProperty< bool >( Actor::Property::SENSITIVE ));
+ DALI_TEST_CHECK(false == actor.GetProperty<bool>(Actor::Property::SENSITIVE));
END_TEST;
}
int UtcDaliActorSetColor(void)
{
TestApplication application;
- Actor actor = Actor::New();
- Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
+ Actor actor = Actor::New();
+ Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
- DALI_TEST_CHECK(color != actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
+ DALI_TEST_CHECK(color != actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
- actor.SetProperty( Actor::Property::COLOR,color);
+ actor.SetProperty(Actor::Property::COLOR, color);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(color == actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
+ DALI_TEST_CHECK(color == actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
- actor.SetProperty( Actor::Property::COLOR, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ) + Vector4( -0.4f, -0.5f, -0.6f, -0.4f ) );
+ actor.SetProperty(Actor::Property::COLOR, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR) + Vector4(-0.4f, -0.5f, -0.6f, -0.4f));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( Vector4( 0.6f, 0.5f, 0.4f, 0.1f ), actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector4(0.6f, 0.5f, 0.4f, 0.1f), actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
- application.GetScene().Add( actor );
- actor.SetProperty( Actor::Property::COLOR, color );
+ application.GetScene().Add(actor);
+ actor.SetProperty(Actor::Property::COLOR, color);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( color, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+ DALI_TEST_EQUALS(color, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ) + Vector4( 1.1f, 1.1f, 1.1f, 1.1f ) );
+ actor.SetProperty(Actor::Property::COLOR, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR) + Vector4(1.1f, 1.1f, 1.1f, 1.1f));
// flush the queue and render once
application.SendNotification();
application.Render();
// Actor color is not clamped
- DALI_TEST_EQUALS( Vector4( 2.1f, 2.1f, 2.1f, 1.6f ), actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector4(2.1f, 2.1f, 2.1f, 1.6f), actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
// world color is clamped
- DALI_TEST_EQUALS( Vector4( 1.0f, 1.0f, 1.0f, 1.0f ), actor.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector4(1.0f, 1.0f, 1.0f, 1.0f), actor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR, color );
- DALI_TEST_EQUALS( color, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR, color);
+ DALI_TEST_EQUALS(color, actor.GetProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
- Vector3 newColor( 1.0f, 0.0f, 0.0f );
- actor.SetProperty( Actor::Property::COLOR, newColor );
- DALI_TEST_EQUALS( Vector4( newColor.r, newColor.g, newColor.b, 1.0f ), actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
+ Vector3 newColor(1.0f, 0.0f, 0.0f);
+ actor.SetProperty(Actor::Property::COLOR, newColor);
+ DALI_TEST_EQUALS(Vector4(newColor.r, newColor.g, newColor.b, 1.0f), actor.GetProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
END_TEST;
}
Actor actor = Actor::New();
Vector4 vector(0.7f, 0.8f, 0.9f, 0.6f);
- DALI_TEST_CHECK(vector != actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
+ DALI_TEST_CHECK(vector != actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
- actor.SetProperty( Actor::Property::COLOR_RED, vector.r );
- DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_RED, vector.r);
+ DALI_TEST_EQUALS(vector.r, actor.GetProperty<float>(Actor::Property::COLOR_RED), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).r, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.r, actor.GetProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.r, actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.r, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).r, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.r, actor.GetProperty<float>(Actor::Property::COLOR_RED), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.r, actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_GREEN, vector.g );
- DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_GREEN, vector.g);
+ DALI_TEST_EQUALS(vector.g, actor.GetProperty<float>(Actor::Property::COLOR_GREEN), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).g, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.g, actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.g, actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.g, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).g, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.g, actor.GetProperty<float>(Actor::Property::COLOR_GREEN), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.g, actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_BLUE, vector.b );
- DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_BLUE, vector.b);
+ DALI_TEST_EQUALS(vector.b, actor.GetProperty<float>(Actor::Property::COLOR_BLUE), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).b, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.b, actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.b, actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), TEST_LOCATION );
-
+ DALI_TEST_EQUALS(vector.b, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).b, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.b, actor.GetProperty<float>(Actor::Property::COLOR_BLUE), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.b, actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_ALPHA, vector.a );
- DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_ALPHA, vector.a);
+ DALI_TEST_EQUALS(vector.a, actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), TEST_LOCATION);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, TEST_LOCATION );
- DALI_TEST_EQUALS( vector.a, actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.a, actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), TEST_LOCATION );
+ DALI_TEST_EQUALS(vector.a, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.a, actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.a, actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), TEST_LOCATION);
- DALI_TEST_EQUALS( vector, actor.GetProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
- DALI_TEST_EQUALS( vector, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), TEST_LOCATION );
-
- actor.SetProperty( Actor::Property::OPACITY, 0.2f );
+ DALI_TEST_EQUALS(vector, actor.GetProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), TEST_LOCATION);
+ actor.SetProperty(Actor::Property::OPACITY, 0.2f);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( 0.2f, actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.2f, actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliActorGetCurrentColor(void)
{
TestApplication application;
- Actor actor = Actor::New();
- Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
+ Actor actor = Actor::New();
+ Vector4 color(1.0f, 1.0f, 1.0f, 0.5f);
- actor.SetProperty( Actor::Property::COLOR,color);
+ actor.SetProperty(Actor::Property::COLOR, color);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK(color == actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
+ DALI_TEST_CHECK(color == actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
END_TEST;
}
tet_infoline("Actor::GetCurrentWorldColor");
TestApplication application;
- Actor parent = Actor::New();
- Vector4 parentColor( 1.0f, 0.5f, 0.0f, 0.8f );
- parent.SetProperty( Actor::Property::COLOR, parentColor );
- application.GetScene().Add( parent );
+ Actor parent = Actor::New();
+ Vector4 parentColor(1.0f, 0.5f, 0.0f, 0.8f);
+ parent.SetProperty(Actor::Property::COLOR, parentColor);
+ application.GetScene().Add(parent);
- Actor child = Actor::New();
- Vector4 childColor( 0.5f, 0.6f, 0.5f, 1.0f );
- child.SetProperty( Actor::Property::COLOR, childColor );
- parent.Add( child );
+ Actor child = Actor::New();
+ Vector4 childColor(0.5f, 0.6f, 0.5f, 1.0f);
+ child.SetProperty(Actor::Property::COLOR, childColor);
+ parent.Add(child);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// verify the default color mode
- DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
+ DALI_TEST_EQUALS(USE_OWN_MULTIPLY_PARENT_ALPHA, child.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
// The actors should not have a world color yet
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), Color::WHITE, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), parentColor, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), childColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::COLOR), parentColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), childColor, TEST_LOCATION);
// The actors should have a world color now
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), parentColor, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), Vector4( childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), parentColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), Vector4(childColor.r, childColor.g, childColor.b, childColor.a * parentColor.a), TEST_LOCATION);
// use own color
- child.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
+ child.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_COLOR);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), childColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), childColor, TEST_LOCATION);
// use parent color
- child.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
+ child.SetProperty(Actor::Property::COLOR_MODE, USE_PARENT_COLOR);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), childColor, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), parentColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), childColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), parentColor, TEST_LOCATION);
// use parent alpha
- child.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
+ child.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA);
application.SendNotification();
application.Render(0);
- Vector4 expectedColor( childColor );
+ Vector4 expectedColor(childColor);
expectedColor.a *= parentColor.a;
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), childColor, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ), expectedColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::COLOR), childColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR), expectedColor, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Actor::SetColorMode");
TestApplication application;
- Actor actor = Actor::New();
- Actor child = Actor::New();
- actor.Add( child );
+ Actor actor = Actor::New();
+ Actor child = Actor::New();
+ actor.Add(child);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
- DALI_TEST_EQUALS( USE_OWN_COLOR, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_COLOR);
+ DALI_TEST_EQUALS(USE_OWN_COLOR, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
- DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR);
+ DALI_TEST_EQUALS(USE_OWN_MULTIPLY_PARENT_COLOR, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
- DALI_TEST_EQUALS( USE_PARENT_COLOR, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_PARENT_COLOR);
+ DALI_TEST_EQUALS(USE_PARENT_COLOR, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
- DALI_TEST_EQUALS( USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA);
+ DALI_TEST_EQUALS(USE_OWN_MULTIPLY_PARENT_ALPHA, actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), TEST_LOCATION);
END_TEST;
}
int UtcDaliActorScreenToLocal(void)
{
TestApplication application;
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::POSITION, Vector2(10.0f, 10.0f));
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
application.GetScene().Add(actor);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, 50.0f, 50.0f) );
+ DALI_TEST_CHECK(actor.ScreenToLocal(localX, localY, 50.0f, 50.0f));
DALI_TEST_EQUALS(localX, 40.0f, 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(localY, 40.0f, 0.01f, TEST_LOCATION);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED,false);
- DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ) == false);
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED) == false);
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED,true);
- DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ) == true);
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED) == true);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ) == false);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED) == false);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, true );
- DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) == true);
+ actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, true);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) == true);
- actor.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, false );
- DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) == false);
+ actor.SetProperty(Actor::Property::KEYBOARD_FOCUSABLE, false);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) == false);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_CHECK(actor.GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE ) == false);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::KEYBOARD_FOCUSABLE) == false);
END_TEST;
}
Actor actor = Actor::New();
- Constraint constraint = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraint() );
+ Constraint constraint = Constraint::New<Vector4>(actor, Actor::Property::COLOR, TestConstraint());
constraint.Apply();
actor.RemoveConstraints();
- DALI_TEST_CHECK( gTestConstraintCalled == false );
+ DALI_TEST_CHECK(gTestConstraintCalled == false);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
constraint.Apply();
// flush the queue and render once
actor.RemoveConstraints();
- DALI_TEST_CHECK( gTestConstraintCalled == true );
+ DALI_TEST_CHECK(gTestConstraintCalled == true);
END_TEST;
}
unsigned int result1 = 0u;
unsigned int result2 = 0u;
- unsigned constraint1Tag = 1u;
- Constraint constraint1 = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1) );
- constraint1.SetTag( constraint1Tag );
+ unsigned constraint1Tag = 1u;
+ Constraint constraint1 = Constraint::New<Vector4>(actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result1, 1));
+ constraint1.SetTag(constraint1Tag);
constraint1.Apply();
- unsigned constraint2Tag = 2u;
- Constraint constraint2 = Constraint::New<Vector4>( actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2) );
- constraint2.SetTag( constraint2Tag );
+ unsigned constraint2Tag = 2u;
+ Constraint constraint2 = Constraint::New<Vector4>(actor, Actor::Property::COLOR, TestConstraintRef<Vector4>(result2, 2));
+ constraint2.SetTag(constraint2Tag);
constraint2.Apply();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(result1, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(result2, 2u, TEST_LOCATION);
// 2. Remove Constraint1 and test...
result1 = 0;
result2 = 0;
actor.RemoveConstraints(constraint1Tag);
// make color property dirty, which will trigger constraints to be reapplied.
- actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
+ actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result1, 0u, TEST_LOCATION ); ///< constraint 1 should not apply now.
- DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(result1, 0u, TEST_LOCATION); ///< constraint 1 should not apply now.
+ DALI_TEST_EQUALS(result2, 2u, TEST_LOCATION);
// 3. Re-Apply Constraint1 and test...
result1 = 0;
result2 = 0;
constraint1.Apply();
// make color property dirty, which will trigger constraints to be reapplied.
- actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
+ actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( result2, 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(result1, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(result2, 2u, TEST_LOCATION);
// 2. Remove Constraint2 and test...
result1 = 0;
result2 = 0;
actor.RemoveConstraints(constraint2Tag);
// make color property dirty, which will trigger constraints to be reapplied.
- actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
+ actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result1, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( result2, 0u, TEST_LOCATION ); ///< constraint 2 should not apply now.
+ DALI_TEST_EQUALS(result1, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(result2, 0u, TEST_LOCATION); ///< constraint 2 should not apply now.
// 2. Remove Constraint1 as well and test...
result1 = 0;
result2 = 0;
actor.RemoveConstraints(constraint1Tag);
// make color property dirty, which will trigger constraints to be reapplied.
- actor.SetProperty( Actor::Property::COLOR, Color::WHITE );
+ actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( result1, 0u, TEST_LOCATION ); ///< constraint 1 should not apply now.
- DALI_TEST_EQUALS( result2, 0u, TEST_LOCATION ); ///< constraint 2 should not apply now.
+ DALI_TEST_EQUALS(result1, 0u, TEST_LOCATION); ///< constraint 1 should not apply now.
+ DALI_TEST_EQUALS(result2, 0u, TEST_LOCATION); ///< constraint 2 should not apply now.
END_TEST;
}
// get the root layer
Actor actor = application.GetScene().GetRootLayer();
- DALI_TEST_CHECK( gTouchCallBackCalled == false );
+ DALI_TEST_CHECK(gTouchCallBackCalled == false);
application.SendNotification();
application.Render();
// connect to its touch signal
- actor.TouchedSignal().Connect( TestTouchCallback );
+ actor.TouchedSignal().Connect(TestTouchCallback);
// simulate a touch event in the middle of the screen
- Vector2 touchPoint( application.GetScene().GetSize() * 0.5 );
+ Vector2 touchPoint(application.GetScene().GetSize() * 0.5);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(touchPoint.x, touchPoint.y));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
- application.ProcessEvent( touchEvent );
+ touchEvent.AddPoint(point);
+ application.ProcessEvent(touchEvent);
- DALI_TEST_CHECK( gTouchCallBackCalled == true );
+ DALI_TEST_CHECK(gTouchCallBackCalled == true);
END_TEST;
}
// get the root layer
Actor actor = application.GetScene().GetRootLayer();
- DALI_TEST_CHECK( gHoverCallBackCalled == false );
+ DALI_TEST_CHECK(gHoverCallBackCalled == false);
application.SendNotification();
application.Render();
// connect to its hover signal
- actor.HoveredSignal().Connect( TestCallback3 );
+ actor.HoveredSignal().Connect(TestCallback3);
// simulate a hover event in the middle of the screen
- Vector2 touchPoint( application.GetScene().GetSize() * 0.5 );
+ Vector2 touchPoint(application.GetScene().GetSize() * 0.5);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::MOTION );
- point.SetScreenPosition( Vector2( touchPoint.x, touchPoint.y ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::MOTION);
+ point.SetScreenPosition(Vector2(touchPoint.x, touchPoint.y));
Dali::Integration::HoverEvent hoverEvent;
- hoverEvent.AddPoint( point );
- application.ProcessEvent( hoverEvent );
+ hoverEvent.AddPoint(point);
+ application.ProcessEvent(hoverEvent);
- DALI_TEST_CHECK( gHoverCallBackCalled == true );
+ DALI_TEST_CHECK(gHoverCallBackCalled == true);
END_TEST;
}
gActorNamesOnOffScene.clear();
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::NAME, "parent" );
- parent.OnSceneSignal().Connect( OnSceneCallback );
- parent.OffSceneSignal().Connect( OffSceneCallback );
+ parent.SetProperty(Actor::Property::NAME, "parent");
+ parent.OnSceneSignal().Connect(OnSceneCallback);
+ parent.OffSceneSignal().Connect(OffSceneCallback);
// sanity check
- DALI_TEST_CHECK( gOnSceneCallBackCalled == 0 );
- DALI_TEST_CHECK( gOffSceneCallBackCalled == 0 );
+ DALI_TEST_CHECK(gOnSceneCallBackCalled == 0);
+ DALI_TEST_CHECK(gOffSceneCallBackCalled == 0);
// add parent to the scene
- application.GetScene().Add( parent );
+ application.GetScene().Add(parent);
// onstage emitted, offstage not
- DALI_TEST_EQUALS( gOnSceneCallBackCalled, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( gOffSceneCallBackCalled, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnSceneCallBackCalled, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(gOffSceneCallBackCalled, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[0], TEST_LOCATION);
// test adding a child, should get onstage emitted
// clean test data
gActorNamesOnOffScene.clear();
Actor child = Actor::New();
- child.SetProperty( Actor::Property::NAME, "child" );
- child.OnSceneSignal().Connect( OnSceneCallback );
- child.OffSceneSignal().Connect( OffSceneCallback );
- parent.Add( child ); // add child
+ child.SetProperty(Actor::Property::NAME, "child");
+ child.OnSceneSignal().Connect(OnSceneCallback);
+ child.OffSceneSignal().Connect(OffSceneCallback);
+ parent.Add(child); // add child
// onscene emitted, offscene not
- DALI_TEST_EQUALS( gOnSceneCallBackCalled, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( gOffSceneCallBackCalled, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnSceneCallBackCalled, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(gOffSceneCallBackCalled, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS("child", gActorNamesOnOffScene[0], TEST_LOCATION);
// test removing parent from the scene
// clean test data
gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
gActorNamesOnOffScene.clear();
- application.GetScene().Remove( parent );
+ application.GetScene().Remove(parent);
// onscene not emitted, offscene is
- DALI_TEST_EQUALS( gOnSceneCallBackCalled, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( gOffSceneCallBackCalled, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnSceneCallBackCalled, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(gOffSceneCallBackCalled, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS("child", gActorNamesOnOffScene[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[1], TEST_LOCATION);
// test adding parent back to the scene
// clean test data
gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
gActorNamesOnOffScene.clear();
- application.GetScene().Add( parent );
+ application.GetScene().Add(parent);
// onscene emitted, offscene not
- DALI_TEST_EQUALS( gOnSceneCallBackCalled, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( gOffSceneCallBackCalled, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnSceneCallBackCalled, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(gOffSceneCallBackCalled, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("child", gActorNamesOnOffScene[1], TEST_LOCATION);
// test removing child
// clean test data
gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
gActorNamesOnOffScene.clear();
- parent.Remove( child );
+ parent.Remove(child);
// onscene not emitted, offscene is
- DALI_TEST_EQUALS( gOnSceneCallBackCalled, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( gOffSceneCallBackCalled, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( "child", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnSceneCallBackCalled, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(gOffSceneCallBackCalled, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS("child", gActorNamesOnOffScene[0], TEST_LOCATION);
// test removing parent
// clean test data
gOnSceneCallBackCalled = gOffSceneCallBackCalled = 0;
gActorNamesOnOffScene.clear();
- application.GetScene().Remove( parent );
+ application.GetScene().Remove(parent);
// onscene not emitted, offscene is
- DALI_TEST_EQUALS( gOnSceneCallBackCalled, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( gOffSceneCallBackCalled, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( "parent", gActorNamesOnOffScene[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnSceneCallBackCalled, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(gOffSceneCallBackCalled, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS("parent", gActorNamesOnOffScene[0], TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::NAME, "parent" );
- Actor first = Actor::New();
- first .SetProperty( Actor::Property::NAME, "first" );
+ parent.SetProperty(Actor::Property::NAME, "parent");
+ Actor first = Actor::New();
+ first.SetProperty(Actor::Property::NAME, "first");
Actor second = Actor::New();
- second.SetProperty( Actor::Property::NAME, "second" );
+ second.SetProperty(Actor::Property::NAME, "second");
parent.Add(first);
first.Add(second);
- Actor found = parent.FindChildByName( "foo" );
- DALI_TEST_CHECK( !found );
+ Actor found = parent.FindChildByName("foo");
+ DALI_TEST_CHECK(!found);
- found = parent.FindChildByName( "parent" );
- DALI_TEST_CHECK( found == parent );
+ found = parent.FindChildByName("parent");
+ DALI_TEST_CHECK(found == parent);
- found = parent.FindChildByName( "first" );
- DALI_TEST_CHECK( found == first );
+ found = parent.FindChildByName("first");
+ DALI_TEST_CHECK(found == first);
- found = parent.FindChildByName( "second" );
- DALI_TEST_CHECK( found == second );
+ found = parent.FindChildByName("second");
+ DALI_TEST_CHECK(found == second);
END_TEST;
}
parent.Add(first);
first.Add(second);
- Actor found = parent.FindChildById( 100000 );
- DALI_TEST_CHECK( !found );
+ Actor found = parent.FindChildById(100000);
+ DALI_TEST_CHECK(!found);
- found = parent.FindChildById( parent.GetProperty< int >( Actor::Property::ID ) );
- DALI_TEST_CHECK( found == parent );
+ found = parent.FindChildById(parent.GetProperty<int>(Actor::Property::ID));
+ DALI_TEST_CHECK(found == parent);
- found = parent.FindChildById( first.GetProperty< int >( Actor::Property::ID ) );
- DALI_TEST_CHECK( found == first );
+ found = parent.FindChildById(first.GetProperty<int>(Actor::Property::ID));
+ DALI_TEST_CHECK(found == first);
- found = parent.FindChildById( second.GetProperty< int >( Actor::Property::ID ) );
- DALI_TEST_CHECK( found == second );
+ found = parent.FindChildById(second.GetProperty<int>(Actor::Property::ID));
+ DALI_TEST_CHECK(found == second);
END_TEST;
}
struct HitTestData
{
public:
- HitTestData( const Vector3& scale, const Vector2& touchPoint, bool result )
- : mScale( scale ),
- mTouchPoint( touchPoint ),
- mResult( result )
- {}
+ HitTestData(const Vector3& scale, const Vector2& touchPoint, bool result)
+ : mScale(scale),
+ mTouchPoint(touchPoint),
+ mResult(result)
+ {
+ }
Vector3 mScale;
Vector2 mTouchPoint;
- bool mResult;
+ bool mResult;
};
TestApplication application;
// Fill a vector with different hit tests.
struct HitTestData* hitTestData[] = {
// scale touch point result
- new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 289.f, 400.f ), true ), // touch point close to the right edge (inside)
- new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 291.f, 400.f ), false ), // touch point close to the right edge (outside)
- new HitTestData( Vector3( 110.f, 100.f, 1.f ), Vector2( 291.f, 400.f ), true ), // same point as above with a wider scale. Should be inside.
- new HitTestData( Vector3( 100.f, 100.f, 1.f ), Vector2( 200.f, 451.f ), false ), // touch point close to the down edge (outside)
- new HitTestData( Vector3( 100.f, 110.f, 1.f ), Vector2( 200.f, 451.f ), true ), // same point as above with a wider scale. Should be inside.
+ new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(289.f, 400.f), true), // touch point close to the right edge (inside)
+ new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(291.f, 400.f), false), // touch point close to the right edge (outside)
+ new HitTestData(Vector3(110.f, 100.f, 1.f), Vector2(291.f, 400.f), true), // same point as above with a wider scale. Should be inside.
+ new HitTestData(Vector3(100.f, 100.f, 1.f), Vector2(200.f, 451.f), false), // touch point close to the down edge (outside)
+ new HitTestData(Vector3(100.f, 110.f, 1.f), Vector2(200.f, 451.f), true), // same point as above with a wider scale. Should be inside.
NULL,
};
// get the root layer
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
ResetTouchCallbacks();
unsigned int index = 0;
- while( NULL != hitTestData[index] )
+ while(NULL != hitTestData[index])
{
- actor.SetProperty( Actor::Property::SIZE, Vector2( 1.f, 1.f ) );
- actor.SetProperty( Actor::Property::SCALE, Vector3( hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(1.f, 1.f));
+ actor.SetProperty(Actor::Property::SCALE, Vector3(hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z));
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( !gTouchCallBackCalled );
+ DALI_TEST_CHECK(!gTouchCallBackCalled);
// connect to its touch signal
actor.TouchedSignal().Connect(TestTouchCallback);
Dali::Integration::Point point;
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y ) );
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y));
Dali::Integration::TouchEvent event;
- event.AddPoint( point );
+ event.AddPoint(point);
// flush the queue and render once
application.SendNotification();
application.Render();
- application.ProcessEvent( event );
+ application.ProcessEvent(event);
- DALI_TEST_CHECK( gTouchCallBackCalled == hitTestData[index]->mResult );
+ DALI_TEST_CHECK(gTouchCallBackCalled == hitTestData[index]->mResult);
- if( gTouchCallBackCalled != hitTestData[index]->mResult )
+ if(gTouchCallBackCalled != hitTestData[index]->mResult)
tet_printf("Test failed:\nScale %f %f %f\nTouchPoint %f, %f\nResult %d\n",
- hitTestData[index]->mScale.x, hitTestData[index]->mScale.y, hitTestData[index]->mScale.z,
- hitTestData[index]->mTouchPoint.x, hitTestData[index]->mTouchPoint.y,
- hitTestData[index]->mResult );
+ hitTestData[index]->mScale.x,
+ hitTestData[index]->mScale.y,
+ hitTestData[index]->mScale.z,
+ hitTestData[index]->mTouchPoint.x,
+ hitTestData[index]->mTouchPoint.y,
+ hitTestData[index]->mResult);
ResetTouchCallbacks();
++index;
application.SendNotification();
application.Render(1);
- DALI_TEST_CHECK( DrawMode::NORMAL == a.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) ); // Ensure overlay is off by default
+ DALI_TEST_CHECK(DrawMode::NORMAL == a.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE)); // Ensure overlay is off by default
- a.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
+ a.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
application.SendNotification();
application.Render(1);
- DALI_TEST_CHECK( DrawMode::OVERLAY_2D == a.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) ); // Check Actor is overlay
+ DALI_TEST_CHECK(DrawMode::OVERLAY_2D == a.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE)); // Check Actor is overlay
- a.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
+ a.SetProperty(Actor::Property::DRAW_MODE, DrawMode::NORMAL);
application.SendNotification();
application.Render(1);
- DALI_TEST_CHECK( DrawMode::NORMAL == a.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) ); // Check Actor is normal
+ DALI_TEST_CHECK(DrawMode::NORMAL == a.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE)); // Check Actor is normal
END_TEST;
}
application.Render(1);
std::vector<GLuint> ids;
- ids.push_back( 8 ); // first rendered actor
- ids.push_back( 9 ); // second rendered actor
- ids.push_back( 10 ); // third rendered actor
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ ids.push_back(8); // first rendered actor
+ ids.push_back(9); // second rendered actor
+ ids.push_back(10); // third rendered actor
+ application.GetGlAbstraction().SetNextTextureIds(ids);
Texture imageA = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
Texture imageB = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
Texture imageC = Texture::New(TextureType::TEXTURE_2D, Pixel::Format::RGBA8888, 16, 16);
- Actor a = CreateRenderableActor( imageA );
- Actor b = CreateRenderableActor( imageB );
- Actor c = CreateRenderableActor( imageC );
+ Actor a = CreateRenderableActor(imageA);
+ Actor b = CreateRenderableActor(imageB);
+ Actor c = CreateRenderableActor(imageC);
application.SendNotification();
application.Render(1);
application.Render(1);
// Should be 3 textures changes.
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
+ const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE0);
typedef std::vector<GLuint>::size_type TextureSize;
- DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>( 3 ), TEST_LOCATION );
- if( boundTextures.size() == 3 )
+ DALI_TEST_EQUALS(boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION);
+ if(boundTextures.size() == 3)
{
- DALI_TEST_CHECK( boundTextures[0] == 8u );
- DALI_TEST_CHECK( boundTextures[1] == 9u );
- DALI_TEST_CHECK( boundTextures[2] == 10u );
+ DALI_TEST_CHECK(boundTextures[0] == 8u);
+ DALI_TEST_CHECK(boundTextures[1] == 9u);
+ DALI_TEST_CHECK(boundTextures[2] == 10u);
}
// Now texture ids have been set, we can monitor their render order.
// b (9)
// c (10)
// a (8)
- a.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
+ a.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
application.GetGlAbstraction().ClearBoundTextures();
application.SendNotification();
application.Render(1);
// Should be 3 texture changes.
- DALI_TEST_EQUALS( boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION );
- if( boundTextures.size() == 3 )
+ DALI_TEST_EQUALS(boundTextures.size(), static_cast<TextureSize>(3), TEST_LOCATION);
+ if(boundTextures.size() == 3)
{
- DALI_TEST_CHECK( boundTextures[0] == 9u );
- DALI_TEST_CHECK( boundTextures[1] == 10u );
- DALI_TEST_CHECK( boundTextures[2] == 8u );
+ DALI_TEST_CHECK(boundTextures[0] == 9u);
+ DALI_TEST_CHECK(boundTextures[1] == 10u);
+ DALI_TEST_CHECK(boundTextures[2] == 8u);
}
END_TEST;
}
tet_infoline(" UtcDaliActorGetCurrentWorldMatrix");
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
- Radian rotationAngle(Degree(85.0f));
+ parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ Vector3 parentPosition(10.0f, 20.0f, 30.0f);
+ Radian rotationAngle(Degree(85.0f));
Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
- Vector3 parentScale( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::POSITION, parentPosition );
- parent.SetProperty( Actor::Property::ORIENTATION, parentRotation );
- parent.SetProperty( Actor::Property::SCALE, parentScale );
- application.GetScene().Add( parent );
+ Vector3 parentScale(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::POSITION, parentPosition);
+ parent.SetProperty(Actor::Property::ORIENTATION, parentRotation);
+ parent.SetProperty(Actor::Property::SCALE, parentScale);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- Vector3 childPosition( 0.0f, 0.0f, 100.0f );
- Radian childRotationAngle(Degree(23.0f));
- Quaternion childRotation( childRotationAngle, Vector3::YAXIS );
- Vector3 childScale( 2.0f, 2.0f, 2.0f );
- child.SetProperty( Actor::Property::POSITION, childPosition );
- child.SetProperty( Actor::Property::ORIENTATION, childRotation );
- child.SetProperty( Actor::Property::SCALE, childScale );
- parent.Add( child );
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Vector3 childPosition(0.0f, 0.0f, 100.0f);
+ Radian childRotationAngle(Degree(23.0f));
+ Quaternion childRotation(childRotationAngle, Vector3::YAXIS);
+ Vector3 childScale(2.0f, 2.0f, 2.0f);
+ child.SetProperty(Actor::Property::POSITION, childPosition);
+ child.SetProperty(Actor::Property::ORIENTATION, childRotation);
+ child.SetProperty(Actor::Property::SCALE, childScale);
+ parent.Add(child);
application.SendNotification();
application.Render(0);
parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
Matrix childMatrix(false);
- childMatrix.SetTransformComponents( childScale, childRotation, childPosition );
+ childMatrix.SetTransformComponents(childScale, childRotation, childPosition);
//Child matrix should be the composition of child and parent
Matrix childWorldMatrix(false);
- Matrix::Multiply( childWorldMatrix, childMatrix, parentMatrix);
+ Matrix::Multiply(childWorldMatrix, childMatrix, parentMatrix);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX ), parentMatrix, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX ), childWorldMatrix, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX), parentMatrix, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX), childWorldMatrix, 0.001, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliActorConstrainedToWorldMatrix(void)
{
TestApplication application;
tet_infoline(" UtcDaliActorConstrainedToWorldMatrix");
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
- Radian rotationAngle(Degree(85.0f));
+ parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ Vector3 parentPosition(10.0f, 20.0f, 30.0f);
+ Radian rotationAngle(Degree(85.0f));
Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
- Vector3 parentScale( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::POSITION, parentPosition );
- parent.SetProperty( Actor::Property::ORIENTATION, parentRotation );
- parent.SetProperty( Actor::Property::SCALE, parentScale );
- application.GetScene().Add( parent );
+ Vector3 parentScale(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::POSITION, parentPosition);
+ parent.SetProperty(Actor::Property::ORIENTATION, parentRotation);
+ parent.SetProperty(Actor::Property::SCALE, parentScale);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- Constraint posConstraint = Constraint::New<Vector3>( child, Actor::Property::POSITION, PositionComponentConstraint() );
- posConstraint.AddSource( Source( parent, Actor::Property::WORLD_MATRIX ) );
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Constraint posConstraint = Constraint::New<Vector3>(child, Actor::Property::POSITION, PositionComponentConstraint());
+ posConstraint.AddSource(Source(parent, Actor::Property::WORLD_MATRIX));
posConstraint.Apply();
- application.GetScene().Add( child );
+ application.GetScene().Add(child);
application.SendNotification();
application.Render(0);
Matrix parentMatrix(false);
parentMatrix.SetTransformComponents(parentScale, parentRotation, parentPosition);
- DALI_TEST_EQUALS( parent.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX ), parentMatrix, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), parent.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX), parentMatrix, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Vector3>(Actor::Property::POSITION), parent.GetCurrentProperty<Vector3>(Actor::Property::POSITION), 0.001, TEST_LOCATION);
END_TEST;
}
tet_infoline(" UtcDaliActorConstrainedToOrientation");
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- Vector3 parentPosition( 10.0f, 20.0f, 30.0f);
- Radian rotationAngle(Degree(85.0f));
+ parent.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ Vector3 parentPosition(10.0f, 20.0f, 30.0f);
+ Radian rotationAngle(Degree(85.0f));
Quaternion parentRotation(rotationAngle, Vector3::ZAXIS);
- Vector3 parentScale( 1.0f, 2.0f, 3.0f );
- parent.SetProperty( Actor::Property::POSITION, parentPosition );
- parent.SetProperty( Actor::Property::ORIENTATION, parentRotation );
- parent.SetProperty( Actor::Property::SCALE, parentScale );
- application.GetScene().Add( parent );
+ Vector3 parentScale(1.0f, 2.0f, 3.0f);
+ parent.SetProperty(Actor::Property::POSITION, parentPosition);
+ parent.SetProperty(Actor::Property::ORIENTATION, parentRotation);
+ parent.SetProperty(Actor::Property::SCALE, parentScale);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- Constraint posConstraint = Constraint::New<Quaternion>( child, Actor::Property::ORIENTATION, OrientationComponentConstraint() );
- posConstraint.AddSource( Source( parent, Actor::Property::ORIENTATION ) );
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Constraint posConstraint = Constraint::New<Quaternion>(child, Actor::Property::ORIENTATION, OrientationComponentConstraint());
+ posConstraint.AddSource(Source(parent, Actor::Property::ORIENTATION));
posConstraint.Apply();
- application.GetScene().Add( child );
+ application.GetScene().Add(child);
application.SendNotification();
application.Render(0);
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( child.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), parent.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), parent.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), 0.001, TEST_LOCATION);
END_TEST;
}
tet_infoline(" UtcDaliActorConstrainedToOpacity");
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::OPACITY, 0.7f );
- application.GetScene().Add( parent );
+ parent.SetProperty(Actor::Property::OPACITY, 0.7f);
+ application.GetScene().Add(parent);
- Actor child = Actor::New();
- Constraint opacityConstraint = Constraint::New<float>( child, Actor::Property::OPACITY, EqualToConstraint() );
- opacityConstraint.AddSource( Source( parent, Actor::Property::OPACITY ) );
+ Actor child = Actor::New();
+ Constraint opacityConstraint = Constraint::New<float>(child, Actor::Property::OPACITY, EqualToConstraint());
+ opacityConstraint.AddSource(Source(parent, Actor::Property::OPACITY));
opacityConstraint.Apply();
- application.GetScene().Add( child );
+ application.GetScene().Add(child);
application.SendNotification();
application.Render(0);
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( child.GetCurrentProperty< float >( Actor::Property::OPACITY ), parent.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<float>(Actor::Property::OPACITY), parent.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.001f, TEST_LOCATION);
- parent.SetProperty( Actor::Property::OPACITY, 0.3f );
+ parent.SetProperty(Actor::Property::OPACITY, 0.3f);
application.SendNotification();
application.Render(0);
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( child.GetCurrentProperty< float >( Actor::Property::OPACITY ), parent.GetCurrentProperty< float >( Actor::Property::OPACITY ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.GetCurrentProperty<float>(Actor::Property::OPACITY), parent.GetCurrentProperty<float>(Actor::Property::OPACITY), 0.001f, TEST_LOCATION);
END_TEST;
}
tet_infoline(" UtcDaliActorUnparent");
Actor parent = Actor::New();
- application.GetScene().Add( parent );
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
- DALI_TEST_CHECK( !child.GetParent() );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
+ DALI_TEST_CHECK(!child.GetParent());
// Test that calling Unparent with no parent is a NOOP
child.Unparent();
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
- DALI_TEST_CHECK( !child.GetParent() );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
+ DALI_TEST_CHECK(!child.GetParent());
// Test that Unparent works
- parent.Add( child );
+ parent.Add(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
- DALI_TEST_CHECK( parent == child.GetParent() );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
+ DALI_TEST_CHECK(parent == child.GetParent());
child.Unparent();
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
- DALI_TEST_CHECK( !child.GetParent() );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
+ DALI_TEST_CHECK(!child.GetParent());
// Test that UnparentAndReset works
- parent.Add( child );
+ parent.Add(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 1u, TEST_LOCATION );
- DALI_TEST_CHECK( parent == child.GetParent() );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 1u, TEST_LOCATION);
+ DALI_TEST_CHECK(parent == child.GetParent());
- UnparentAndReset( child );
+ UnparentAndReset(child);
- DALI_TEST_EQUALS( parent.GetChildCount(), 0u, TEST_LOCATION );
- DALI_TEST_CHECK( !child );
+ DALI_TEST_EQUALS(parent.GetChildCount(), 0u, TEST_LOCATION);
+ DALI_TEST_CHECK(!child);
// Test that UnparentAndReset is a NOOP with empty handle
- UnparentAndReset( child );
+ UnparentAndReset(child);
- DALI_TEST_CHECK( !child );
+ DALI_TEST_CHECK(!child);
END_TEST;
}
tet_infoline(" UtcDaliActorGetChildAt");
Actor parent = Actor::New();
- application.GetScene().Add( parent );
+ application.GetScene().Add(parent);
Actor child0 = Actor::New();
- parent.Add( child0 );
+ parent.Add(child0);
Actor child1 = Actor::New();
- parent.Add( child1 );
+ parent.Add(child1);
Actor child2 = Actor::New();
- parent.Add( child2 );
+ parent.Add(child2);
- DALI_TEST_EQUALS( parent.GetChildAt( 0 ), child0, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetChildAt( 1 ), child1, TEST_LOCATION );
- DALI_TEST_EQUALS( parent.GetChildAt( 2 ), child2, TEST_LOCATION );
+ DALI_TEST_EQUALS(parent.GetChildAt(0), child0, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetChildAt(1), child1, TEST_LOCATION);
+ DALI_TEST_EQUALS(parent.GetChildAt(2), child2, TEST_LOCATION);
END_TEST;
}
tet_infoline(" UtcDaliActorSetGetOverlay");
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::DRAW_MODE,DrawMode::OVERLAY_2D );
- DALI_TEST_CHECK( parent.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ) == DrawMode::OVERLAY_2D );
+ parent.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
+ DALI_TEST_CHECK(parent.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE) == DrawMode::OVERLAY_2D);
END_TEST;
}
-
int UtcDaliActorCreateDestroy(void)
{
Actor* actor = new Actor;
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
delete actor;
END_TEST;
}
{
struct PropertyStringIndex
{
- const char * const name;
+ const char* const name;
const Property::Index index;
- const Property::Type type;
+ const Property::Type type;
};
const PropertyStringIndex PROPERTY_TABLE[] =
-{
- { "parentOrigin", Actor::Property::PARENT_ORIGIN, Property::VECTOR3 },
- { "parentOriginX", Actor::Property::PARENT_ORIGIN_X, Property::FLOAT },
- { "parentOriginY", Actor::Property::PARENT_ORIGIN_Y, Property::FLOAT },
- { "parentOriginZ", Actor::Property::PARENT_ORIGIN_Z, Property::FLOAT },
- { "anchorPoint", Actor::Property::ANCHOR_POINT, Property::VECTOR3 },
- { "anchorPointX", Actor::Property::ANCHOR_POINT_X, Property::FLOAT },
- { "anchorPointY", Actor::Property::ANCHOR_POINT_Y, Property::FLOAT },
- { "anchorPointZ", Actor::Property::ANCHOR_POINT_Z, Property::FLOAT },
- { "size", Actor::Property::SIZE, Property::VECTOR3 },
- { "sizeWidth", Actor::Property::SIZE_WIDTH, Property::FLOAT },
- { "sizeHeight", Actor::Property::SIZE_HEIGHT, Property::FLOAT },
- { "sizeDepth", Actor::Property::SIZE_DEPTH, Property::FLOAT },
- { "position", Actor::Property::POSITION, Property::VECTOR3 },
- { "positionX", Actor::Property::POSITION_X, Property::FLOAT },
- { "positionY", Actor::Property::POSITION_Y, Property::FLOAT },
- { "positionZ", Actor::Property::POSITION_Z, Property::FLOAT },
- { "worldPosition", Actor::Property::WORLD_POSITION, Property::VECTOR3 },
- { "worldPositionX", Actor::Property::WORLD_POSITION_X, Property::FLOAT },
- { "worldPositionY", Actor::Property::WORLD_POSITION_Y, Property::FLOAT },
- { "worldPositionZ", Actor::Property::WORLD_POSITION_Z, Property::FLOAT },
- { "orientation", Actor::Property::ORIENTATION, Property::ROTATION },
- { "worldOrientation", Actor::Property::WORLD_ORIENTATION, Property::ROTATION },
- { "scale", Actor::Property::SCALE, Property::VECTOR3 },
- { "scaleX", Actor::Property::SCALE_X, Property::FLOAT },
- { "scaleY", Actor::Property::SCALE_Y, Property::FLOAT },
- { "scaleZ", Actor::Property::SCALE_Z, Property::FLOAT },
- { "worldScale", Actor::Property::WORLD_SCALE, Property::VECTOR3 },
- { "visible", Actor::Property::VISIBLE, Property::BOOLEAN },
- { "color", Actor::Property::COLOR, Property::VECTOR4 },
- { "colorRed", Actor::Property::COLOR_RED, Property::FLOAT },
- { "colorGreen", Actor::Property::COLOR_GREEN, Property::FLOAT },
- { "colorBlue", Actor::Property::COLOR_BLUE, Property::FLOAT },
- { "colorAlpha", Actor::Property::COLOR_ALPHA, Property::FLOAT },
- { "worldColor", Actor::Property::WORLD_COLOR, Property::VECTOR4 },
- { "worldMatrix", Actor::Property::WORLD_MATRIX, Property::MATRIX },
- { "name", Actor::Property::NAME, Property::STRING },
- { "sensitive", Actor::Property::SENSITIVE, Property::BOOLEAN },
- { "leaveRequired", Actor::Property::LEAVE_REQUIRED, Property::BOOLEAN },
- { "inheritOrientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN },
- { "inheritScale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN },
- { "colorMode", Actor::Property::COLOR_MODE, Property::INTEGER },
- { "drawMode", Actor::Property::DRAW_MODE, Property::INTEGER },
- { "sizeModeFactor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3 },
- { "widthResizePolicy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING },
- { "heightResizePolicy", Actor::Property::HEIGHT_RESIZE_POLICY, Property::STRING },
- { "sizeScalePolicy", Actor::Property::SIZE_SCALE_POLICY, Property::INTEGER },
- { "widthForHeight", Actor::Property::WIDTH_FOR_HEIGHT, Property::BOOLEAN },
- { "heightForWidth", Actor::Property::HEIGHT_FOR_WIDTH, Property::BOOLEAN },
- { "padding", Actor::Property::PADDING, Property::VECTOR4 },
- { "minimumSize", Actor::Property::MINIMUM_SIZE, Property::VECTOR2 },
- { "maximumSize", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2 },
- { "inheritPosition", Actor::Property::INHERIT_POSITION, Property::BOOLEAN },
- { "clippingMode", Actor::Property::CLIPPING_MODE, Property::STRING },
- { "opacity", Actor::Property::OPACITY, Property::FLOAT },
+ {
+ {"parentOrigin", Actor::Property::PARENT_ORIGIN, Property::VECTOR3},
+ {"parentOriginX", Actor::Property::PARENT_ORIGIN_X, Property::FLOAT},
+ {"parentOriginY", Actor::Property::PARENT_ORIGIN_Y, Property::FLOAT},
+ {"parentOriginZ", Actor::Property::PARENT_ORIGIN_Z, Property::FLOAT},
+ {"anchorPoint", Actor::Property::ANCHOR_POINT, Property::VECTOR3},
+ {"anchorPointX", Actor::Property::ANCHOR_POINT_X, Property::FLOAT},
+ {"anchorPointY", Actor::Property::ANCHOR_POINT_Y, Property::FLOAT},
+ {"anchorPointZ", Actor::Property::ANCHOR_POINT_Z, Property::FLOAT},
+ {"size", Actor::Property::SIZE, Property::VECTOR3},
+ {"sizeWidth", Actor::Property::SIZE_WIDTH, Property::FLOAT},
+ {"sizeHeight", Actor::Property::SIZE_HEIGHT, Property::FLOAT},
+ {"sizeDepth", Actor::Property::SIZE_DEPTH, Property::FLOAT},
+ {"position", Actor::Property::POSITION, Property::VECTOR3},
+ {"positionX", Actor::Property::POSITION_X, Property::FLOAT},
+ {"positionY", Actor::Property::POSITION_Y, Property::FLOAT},
+ {"positionZ", Actor::Property::POSITION_Z, Property::FLOAT},
+ {"worldPosition", Actor::Property::WORLD_POSITION, Property::VECTOR3},
+ {"worldPositionX", Actor::Property::WORLD_POSITION_X, Property::FLOAT},
+ {"worldPositionY", Actor::Property::WORLD_POSITION_Y, Property::FLOAT},
+ {"worldPositionZ", Actor::Property::WORLD_POSITION_Z, Property::FLOAT},
+ {"orientation", Actor::Property::ORIENTATION, Property::ROTATION},
+ {"worldOrientation", Actor::Property::WORLD_ORIENTATION, Property::ROTATION},
+ {"scale", Actor::Property::SCALE, Property::VECTOR3},
+ {"scaleX", Actor::Property::SCALE_X, Property::FLOAT},
+ {"scaleY", Actor::Property::SCALE_Y, Property::FLOAT},
+ {"scaleZ", Actor::Property::SCALE_Z, Property::FLOAT},
+ {"worldScale", Actor::Property::WORLD_SCALE, Property::VECTOR3},
+ {"visible", Actor::Property::VISIBLE, Property::BOOLEAN},
+ {"color", Actor::Property::COLOR, Property::VECTOR4},
+ {"colorRed", Actor::Property::COLOR_RED, Property::FLOAT},
+ {"colorGreen", Actor::Property::COLOR_GREEN, Property::FLOAT},
+ {"colorBlue", Actor::Property::COLOR_BLUE, Property::FLOAT},
+ {"colorAlpha", Actor::Property::COLOR_ALPHA, Property::FLOAT},
+ {"worldColor", Actor::Property::WORLD_COLOR, Property::VECTOR4},
+ {"worldMatrix", Actor::Property::WORLD_MATRIX, Property::MATRIX},
+ {"name", Actor::Property::NAME, Property::STRING},
+ {"sensitive", Actor::Property::SENSITIVE, Property::BOOLEAN},
+ {"leaveRequired", Actor::Property::LEAVE_REQUIRED, Property::BOOLEAN},
+ {"inheritOrientation", Actor::Property::INHERIT_ORIENTATION, Property::BOOLEAN},
+ {"inheritScale", Actor::Property::INHERIT_SCALE, Property::BOOLEAN},
+ {"colorMode", Actor::Property::COLOR_MODE, Property::INTEGER},
+ {"drawMode", Actor::Property::DRAW_MODE, Property::INTEGER},
+ {"sizeModeFactor", Actor::Property::SIZE_MODE_FACTOR, Property::VECTOR3},
+ {"widthResizePolicy", Actor::Property::WIDTH_RESIZE_POLICY, Property::STRING},
+ {"heightResizePolicy", Actor::Property::HEIGHT_RESIZE_POLICY, Property::STRING},
+ {"sizeScalePolicy", Actor::Property::SIZE_SCALE_POLICY, Property::INTEGER},
+ {"widthForHeight", Actor::Property::WIDTH_FOR_HEIGHT, Property::BOOLEAN},
+ {"heightForWidth", Actor::Property::HEIGHT_FOR_WIDTH, Property::BOOLEAN},
+ {"padding", Actor::Property::PADDING, Property::VECTOR4},
+ {"minimumSize", Actor::Property::MINIMUM_SIZE, Property::VECTOR2},
+ {"maximumSize", Actor::Property::MAXIMUM_SIZE, Property::VECTOR2},
+ {"inheritPosition", Actor::Property::INHERIT_POSITION, Property::BOOLEAN},
+ {"clippingMode", Actor::Property::CLIPPING_MODE, Property::STRING},
+ {"opacity", Actor::Property::OPACITY, Property::FLOAT},
};
-const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
+const unsigned int PROPERTY_TABLE_COUNT = sizeof(PROPERTY_TABLE) / sizeof(PROPERTY_TABLE[0]);
} // unnamed namespace
int UtcDaliActorProperties(void)
Actor actor = Actor::New();
- for ( unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i )
+ for(unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i)
{
- tet_printf( "Checking %s == %d\n", PROPERTY_TABLE[i].name, PROPERTY_TABLE[i].index );
- DALI_TEST_EQUALS( actor.GetPropertyName( PROPERTY_TABLE[i].index ), PROPERTY_TABLE[i].name, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetPropertyIndex( PROPERTY_TABLE[i].name ), PROPERTY_TABLE[i].index, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetPropertyType( PROPERTY_TABLE[i].index ), PROPERTY_TABLE[i].type, TEST_LOCATION );
+ tet_printf("Checking %s == %d\n", PROPERTY_TABLE[i].name, PROPERTY_TABLE[i].index);
+ DALI_TEST_EQUALS(actor.GetPropertyName(PROPERTY_TABLE[i].index), PROPERTY_TABLE[i].name, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetPropertyIndex(PROPERTY_TABLE[i].name), PROPERTY_TABLE[i].index, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetPropertyType(PROPERTY_TABLE[i].index), PROPERTY_TABLE[i].type, TEST_LOCATION);
}
END_TEST;
}
Actor actor = Actor::New();
// Defaults
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), "USE_NATURAL_SIZE", TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), "USE_NATURAL_SIZE", TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_RESIZE_POLICY).Get<std::string>(), "USE_NATURAL_SIZE", TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_RESIZE_POLICY).Get<std::string>(), "USE_NATURAL_SIZE", TEST_LOCATION);
// Set resize policy for all dimensions
- actor.SetResizePolicy( ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS );
- for( unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i)
+ actor.SetResizePolicy(ResizePolicy::USE_NATURAL_SIZE, Dimension::ALL_DIMENSIONS);
+ for(unsigned int i = 0; i < Dimension::DIMENSION_COUNT; ++i)
{
- DALI_TEST_EQUALS( actor.GetResizePolicy( static_cast< Dimension::Type >( 1 << i ) ), ResizePolicy::USE_NATURAL_SIZE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetResizePolicy(static_cast<Dimension::Type>(1 << i)), ResizePolicy::USE_NATURAL_SIZE, TEST_LOCATION);
}
// Set individual dimensions
- const char* const widthPolicy = "FILL_TO_PARENT";
+ const char* const widthPolicy = "FILL_TO_PARENT";
const char* const heightPolicy = "FIXED";
- actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicy );
- actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicy );
+ actor.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, widthPolicy);
+ actor.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicy);
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_RESIZE_POLICY ).Get< std::string >(), widthPolicy, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_RESIZE_POLICY ).Get< std::string >(), heightPolicy, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_RESIZE_POLICY).Get<std::string>(), widthPolicy, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_RESIZE_POLICY).Get<std::string>(), heightPolicy, TEST_LOCATION);
// Set individual dimensions using enums
- ResizePolicy::Type widthPolicyEnum = ResizePolicy::USE_ASSIGNED_SIZE;
+ ResizePolicy::Type widthPolicyEnum = ResizePolicy::USE_ASSIGNED_SIZE;
ResizePolicy::Type heightPolicyEnum = ResizePolicy::SIZE_RELATIVE_TO_PARENT;
- actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, widthPolicyEnum );
- actor.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicyEnum );
+ actor.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, widthPolicyEnum);
+ actor.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, heightPolicyEnum);
- DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::WIDTH ) ), static_cast< int >( widthPolicyEnum ), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast< int >( actor.GetResizePolicy( Dimension::HEIGHT ) ), static_cast< int >( heightPolicyEnum ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(actor.GetResizePolicy(Dimension::WIDTH)), static_cast<int>(widthPolicyEnum), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<int>(actor.GetResizePolicy(Dimension::HEIGHT)), static_cast<int>(heightPolicyEnum), TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Defaults
- DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), SizeScalePolicy::USE_SIZE_SET, TEST_LOCATION);
SizeScalePolicy::Type policy = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
- actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy );
- DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), policy, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_SCALE_POLICY, policy);
+ DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), policy, TEST_LOCATION);
// Set
const SizeScalePolicy::Type policy1 = SizeScalePolicy::FIT_WITH_ASPECT_RATIO;
const SizeScalePolicy::Type policy2 = SizeScalePolicy::FILL_WITH_ASPECT_RATIO;
- actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy1 );
- DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), policy1, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_SCALE_POLICY, policy1);
+ DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), policy1, TEST_LOCATION);
- actor.SetProperty( Actor::Property::SIZE_SCALE_POLICY, policy2 );
- DALI_TEST_EQUALS( actor.GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY ), policy2, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_SCALE_POLICY, policy2);
+ DALI_TEST_EQUALS(actor.GetProperty<SizeScalePolicy::Type>(Actor::Property::SIZE_SCALE_POLICY), policy2, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Defaults
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR ), Vector3( 1.0f, 1.0f, 1.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_MODE_FACTOR).Get<Vector3>(), Vector3(1.0f, 1.0f, 1.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR), Vector3(1.0f, 1.0f, 1.0f), TEST_LOCATION);
- Vector3 sizeMode( 1.0f, 2.0f, 3.0f );
- actor.SetProperty( Actor::Property::SIZE_MODE_FACTOR, sizeMode );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR ), sizeMode, TEST_LOCATION );
+ Vector3 sizeMode(1.0f, 2.0f, 3.0f);
+ actor.SetProperty(Actor::Property::SIZE_MODE_FACTOR, sizeMode);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE_MODE_FACTOR), sizeMode, TEST_LOCATION);
// Set
- Vector3 sizeMode1( 2.0f, 3.0f, 4.0f );
+ Vector3 sizeMode1(2.0f, 3.0f, 4.0f);
- actor.SetProperty( Actor::Property::SIZE_MODE_FACTOR, sizeMode1 );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::SIZE_MODE_FACTOR ).Get< Vector3 >(), sizeMode1, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::SIZE_MODE_FACTOR, sizeMode1);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE_MODE_FACTOR).Get<Vector3>(), sizeMode1, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Defaults
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_FOR_HEIGHT).Get<bool>(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_FOR_WIDTH).Get<bool>(), false, TEST_LOCATION);
// Set
- actor.SetProperty( Actor::Property::WIDTH_FOR_HEIGHT, true );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), true, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::WIDTH_FOR_HEIGHT, true);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_FOR_HEIGHT).Get<bool>(), true, TEST_LOCATION);
- actor.SetProperty( Actor::Property::HEIGHT_FOR_WIDTH, true );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::HEIGHT_FOR_WIDTH ).Get< bool >(), true, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::HEIGHT_FOR_WIDTH, true);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::HEIGHT_FOR_WIDTH).Get<bool>(), true, TEST_LOCATION);
// Test setting another resize policy
- actor.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FIXED" );
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::WIDTH_FOR_HEIGHT ).Get< bool >(), false, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FIXED");
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::WIDTH_FOR_HEIGHT).Get<bool>(), false, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Data
- Vector4 padding( 1.0f, 2.0f, 3.0f, 4.0f );
+ Vector4 padding(1.0f, 2.0f, 3.0f, 4.0f);
// PADDING
- actor.SetProperty( Actor::Property::PADDING, padding );
- Vector4 paddingResult = actor.GetProperty( Actor::Property::PADDING ).Get< Vector4 >();
+ actor.SetProperty(Actor::Property::PADDING, padding);
+ Vector4 paddingResult = actor.GetProperty(Actor::Property::PADDING).Get<Vector4>();
- DALI_TEST_EQUALS( paddingResult, padding, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ DALI_TEST_EQUALS(paddingResult, padding, Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Data
- Vector2 minSize( 1.0f, 2.0f );
+ Vector2 minSize(1.0f, 2.0f);
- actor.SetProperty( Actor::Property::MINIMUM_SIZE, minSize );
- Vector2 resultMin = actor.GetProperty( Actor::Property::MINIMUM_SIZE ).Get< Vector2 >();
+ actor.SetProperty(Actor::Property::MINIMUM_SIZE, minSize);
+ Vector2 resultMin = actor.GetProperty(Actor::Property::MINIMUM_SIZE).Get<Vector2>();
- DALI_TEST_EQUALS( resultMin, minSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ DALI_TEST_EQUALS(resultMin, minSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- Vector2 maxSize( 3.0f, 4.0f );
+ Vector2 maxSize(3.0f, 4.0f);
- actor.SetProperty( Actor::Property::MAXIMUM_SIZE, maxSize );
- Vector2 resultMax = actor.GetProperty( Actor::Property::MAXIMUM_SIZE ).Get< Vector2 >();
+ actor.SetProperty(Actor::Property::MAXIMUM_SIZE, maxSize);
+ Vector2 resultMax = actor.GetProperty(Actor::Property::MAXIMUM_SIZE).Get<Vector2>();
- DALI_TEST_EQUALS( resultMax, maxSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ DALI_TEST_EQUALS(resultMax, maxSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetHeightForWidth( 1.0f ), 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetHeightForWidth(1.0f), 1.0f, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetWidthForHeight( 1.0f ), 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetWidthForHeight(1.0f), 1.0f, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Add actor to stage
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRelayoutSize(Dimension::WIDTH), 0.0f, TEST_LOCATION);
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::WIDTH );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 0.0f ) );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::WIDTH);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 0.0f));
// Flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetRelayoutSize( Dimension::WIDTH ), 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRelayoutSize(Dimension::WIDTH), 1.0f, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
Padding padding;
- padding = actor.GetProperty<Vector4>( Actor::Property::PADDING );
+ padding = actor.GetProperty<Vector4>(Actor::Property::PADDING);
- DALI_TEST_EQUALS( padding.left, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( padding.right, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( padding.bottom, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( padding.top, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(padding.left, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(padding.right, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(padding.bottom, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(padding.top, 0.0f, TEST_LOCATION);
- Padding padding2( 1.0f, 2.0f, 3.0f, 4.0f );
- actor.SetProperty( Actor::Property::PADDING, padding2 );
+ Padding padding2(1.0f, 2.0f, 3.0f, 4.0f);
+ actor.SetProperty(Actor::Property::PADDING, padding2);
- padding = actor.GetProperty<Vector4>( Actor::Property::PADDING );
+ padding = actor.GetProperty<Vector4>(Actor::Property::PADDING);
- DALI_TEST_EQUALS( padding.left, padding2.left, TEST_LOCATION );
- DALI_TEST_EQUALS( padding.right, padding2.right, TEST_LOCATION );
- DALI_TEST_EQUALS( padding.bottom, padding2.bottom, TEST_LOCATION );
- DALI_TEST_EQUALS( padding.top, padding2.top, TEST_LOCATION );
+ DALI_TEST_EQUALS(padding.left, padding2.left, TEST_LOCATION);
+ DALI_TEST_EQUALS(padding.right, padding2.right, TEST_LOCATION);
+ DALI_TEST_EQUALS(padding.bottom, padding2.bottom, TEST_LOCATION);
+ DALI_TEST_EQUALS(padding.top, padding2.top, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Vector2 size = actor.GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
+ Vector2 size = actor.GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
- DALI_TEST_EQUALS( size.width, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( size.height, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(size.width, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(size.height, 0.0f, TEST_LOCATION);
- Vector2 size2( 1.0f, 2.0f );
- actor.SetProperty( Actor::Property::MINIMUM_SIZE, size2 );
+ Vector2 size2(1.0f, 2.0f);
+ actor.SetProperty(Actor::Property::MINIMUM_SIZE, size2);
- size = actor.GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
+ size = actor.GetProperty<Vector2>(Actor::Property::MINIMUM_SIZE);
- DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
- DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
+ DALI_TEST_EQUALS(size.width, size2.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(size.height, size2.height, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Vector2 size = actor.GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
+ Vector2 size = actor.GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
- DALI_TEST_EQUALS( size.width, FLT_MAX, TEST_LOCATION );
- DALI_TEST_EQUALS( size.height, FLT_MAX, TEST_LOCATION );
+ DALI_TEST_EQUALS(size.width, FLT_MAX, TEST_LOCATION);
+ DALI_TEST_EQUALS(size.height, FLT_MAX, TEST_LOCATION);
- Vector2 size2( 1.0f, 2.0f );
- actor.SetProperty( Actor::Property::MAXIMUM_SIZE, size2 );
+ Vector2 size2(1.0f, 2.0f);
+ actor.SetProperty(Actor::Property::MAXIMUM_SIZE, size2);
- size = actor.GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
+ size = actor.GetProperty<Vector2>(Actor::Property::MAXIMUM_SIZE);
- DALI_TEST_EQUALS( size.width, size2.width, TEST_LOCATION );
- DALI_TEST_EQUALS( size.height, size2.height, TEST_LOCATION );
+ DALI_TEST_EQUALS(size.width, size2.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(size.height, size2.height, TEST_LOCATION);
END_TEST;
}
gActorNamesRelayout.clear();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::NAME, "actor" );
- actor.OnRelayoutSignal().Connect( OnRelayoutCallback );
+ actor.SetProperty(Actor::Property::NAME, "actor");
+ actor.OnRelayoutSignal().Connect(OnRelayoutCallback);
// Sanity check
- DALI_TEST_CHECK( ! gOnRelayoutCallBackCalled );
+ DALI_TEST_CHECK(!gOnRelayoutCallBackCalled);
// Add actor to stage
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 2.0 ) );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 2.0));
// Flush the queue and render once
application.SendNotification();
application.Render();
// OnRelayout emitted
- DALI_TEST_EQUALS( gOnRelayoutCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( "actor", gActorNamesRelayout[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(gOnRelayoutCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS("actor", gActorNamesRelayout[0], TEST_LOCATION);
END_TEST;
}
TestApplication application;
tet_infoline("Testing Dali::Actor::GetHierarchyDepth()");
-
/* Build tree of actors:
*
* Depth
*
* GetHierarchyDepth should return 1 for A, 2 for B and C, and 3 for D, E and F.
*/
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorF = Actor::New();
//Test that root actor has depth equal 0
- DALI_TEST_EQUALS( 0, stage.GetRootLayer().GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, stage.GetRootLayer().GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
//Test actors return depth -1 when not connected to the tree
- DALI_TEST_EQUALS( -1, actorA.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorC.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorF.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+ DALI_TEST_EQUALS(-1, actorA.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorC.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorF.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
//Create the hierarchy
- stage.Add( actorA );
- actorA.Add( actorB );
- actorA.Add( actorC );
- actorB.Add( actorD );
- actorB.Add( actorE );
- actorC.Add( actorF );
+ stage.Add(actorA);
+ actorA.Add(actorB);
+ actorA.Add(actorC);
+ actorB.Add(actorD);
+ actorB.Add(actorE);
+ actorC.Add(actorF);
//Test actors return correct depth
- DALI_TEST_EQUALS( 1, actorA.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( 2, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( 2, actorC.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( 3, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( 3, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( 3, actorF.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, actorA.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(2, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(2, actorC.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(3, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(3, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(3, actorF.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
//Removing actorB from the hierarchy. actorB, actorD and actorE should now have depth equal -1
- actorA.Remove( actorB );
+ actorA.Remove(actorB);
- DALI_TEST_EQUALS( -1, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+ DALI_TEST_EQUALS(-1, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
//Removing actorA from the stage. All actors should have depth equal -1
- stage.Remove( actorA );
+ stage.Remove(actorA);
- DALI_TEST_EQUALS( -1, actorA.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorB.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorC.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorD.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorE.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, actorF.GetProperty< int >( Actor::Property::HIERARCHY_DEPTH ), TEST_LOCATION );
+ DALI_TEST_EQUALS(-1, actorA.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorB.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorC.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorD.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorE.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, actorF.GetProperty<int>(Actor::Property::HIERARCHY_DEPTH), TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_LEFT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "TOP_LEFT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::TOP_LEFT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_CENTER" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "TOP_CENTER");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::TOP_CENTER, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "TOP_RIGHT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "TOP_RIGHT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::TOP_RIGHT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_LEFT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "CENTER_LEFT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::CENTER_LEFT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::CENTER, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "CENTER");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::CENTER, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "CENTER_RIGHT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "CENTER_RIGHT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::CENTER_RIGHT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "BOTTOM_LEFT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "BOTTOM_CENTER");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION);
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "BOTTOM_RIGHT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
// Invalid should not change anything
- actor.SetProperty( Actor::Property::ANCHOR_POINT, "INVALID_ARG" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, "INVALID_ARG");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_LEFT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "TOP_LEFT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_LEFT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_CENTER" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_CENTER, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "TOP_CENTER");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_CENTER, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "TOP_RIGHT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "TOP_RIGHT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_RIGHT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_LEFT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::CENTER_LEFT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "CENTER_LEFT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::CENTER_LEFT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::CENTER, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "CENTER");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::CENTER, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::CENTER_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "CENTER_RIGHT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::CENTER_RIGHT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "BOTTOM_LEFT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_LEFT, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "BOTTOM_CENTER");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_CENTER, TEST_LOCATION);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "BOTTOM_RIGHT");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
// Invalid should not change anything
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, "INVALID_ARG" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, "INVALID_ARG");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::BOTTOM_RIGHT, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_COLOR" );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_COLOR, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, "USE_OWN_COLOR");
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_COLOR, TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, "USE_PARENT_COLOR" );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_PARENT_COLOR, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, "USE_PARENT_COLOR");
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_PARENT_COLOR, TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR" );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_COLOR");
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_ALPHA" );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, "USE_OWN_MULTIPLY_PARENT_ALPHA");
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION);
// Invalid should not change anything
- actor.SetProperty( Actor::Property::COLOR_MODE, "INVALID_ARG" );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, "INVALID_ARG");
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::DRAW_MODE, "NORMAL" );
- DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::NORMAL, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::DRAW_MODE, "NORMAL");
+ DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::NORMAL, TEST_LOCATION);
- actor.SetProperty( Actor::Property::DRAW_MODE, "OVERLAY_2D" );
- DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::DRAW_MODE, "OVERLAY_2D");
+ DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
// Invalid should not change anything
- actor.SetProperty( Actor::Property::DRAW_MODE, "INVALID_ARG" );
- DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::DRAW_MODE, "INVALID_ARG");
+ DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_COLOR );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_COLOR, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_COLOR);
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_COLOR, TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_PARENT_COLOR );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_PARENT_COLOR, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_PARENT_COLOR);
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_PARENT_COLOR, TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_COLOR);
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_COLOR, TEST_LOCATION);
- actor.SetProperty( Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA );
- DALI_TEST_EQUALS( actor.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::COLOR_MODE, USE_OWN_MULTIPLY_PARENT_ALPHA);
+ DALI_TEST_EQUALS(actor.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_OWN_MULTIPLY_PARENT_ALPHA, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::NORMAL );
- DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::NORMAL, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::DRAW_MODE, DrawMode::NORMAL);
+ DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::NORMAL, TEST_LOCATION);
- actor.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
- DALI_TEST_EQUALS( actor.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
+ DALI_TEST_EQUALS(actor.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- actor.AddRenderer( renderer );
- DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
+ actor.AddRenderer(renderer);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Actor::AddRenderer");
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Renderer renderer;
// try illegal Add
try
{
- actor.AddRenderer( renderer );
- tet_printf("Assertion test failed - no Exception\n" );
+ actor.AddRenderer(renderer);
+ tet_printf("Assertion test failed - no Exception\n");
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "Renderer handle is empty", TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
int UtcDaliActorAddRendererN02(void)
{
- tet_infoline( "UtcDaliActorAddRendererN02" );
+ tet_infoline("UtcDaliActorAddRendererN02");
- Actor actor;
+ Actor actor;
Renderer renderer;
{
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ renderer = Renderer::New(geometry, shader);
actor = Actor::New();
}
// try illegal AddRenderer
try
{
- actor.AddRenderer( renderer );
- tet_printf( "Assertion test failed - no Exception\n" );
- tet_result( TET_FAIL );
+ actor.AddRenderer(renderer);
+ tet_printf("Assertion test failed - no Exception\n");
+ tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "EventThreadServices::IsCoreRunning()", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "EventThreadServices::IsCoreRunning()", TEST_LOCATION);
}
catch(...)
{
- tet_printf( "Assertion test failed - wrong Exception\n" );
- tet_result( TET_FAIL );
+ tet_printf("Assertion test failed - wrong Exception\n");
+ tet_result(TET_FAIL);
}
END_TEST;
application.Render(0);
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
application.SendNotification();
try
{
- actor.AddRenderer( renderer );
+ actor.AddRenderer(renderer);
tet_result(TET_PASS);
}
catch(...)
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
{
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- actor.AddRenderer( renderer );
- DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
+ actor.AddRenderer(renderer);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
application.SendNotification();
application.Render();
{
Renderer renderer = actor.GetRendererAt(0);
actor.RemoveRenderer(renderer);
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
application.SendNotification();
application.Render();
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- actor.AddRenderer( renderer );
+ actor.AddRenderer(renderer);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
actor.RemoveRenderer(0);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
// Shut down whilst holding onto the renderer handle.
END_TEST;
}
-
int UtcDaliActorRemoveRendererN(void)
{
tet_infoline("Testing Actor::RemoveRenderer");
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetRendererCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 0u, TEST_LOCATION);
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- actor.AddRenderer( renderer );
- DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
+ actor.AddRenderer(renderer);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
actor.RemoveRenderer(10);
- DALI_TEST_EQUALS( actor.GetRendererAt(0), renderer, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetRendererCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetRendererAt(0), renderer, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetRendererCount(), 1u, TEST_LOCATION);
END_TEST;
}
// Clipping test helper functions:
-Actor CreateActorWithContent( uint32_t width, uint32_t height)
+Actor CreateActorWithContent(uint32_t width, uint32_t height)
{
- Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- Actor actor = CreateRenderableActor( image );
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ Actor actor = CreateRenderableActor(image);
// Setup dimensions and position so actor is not skipped by culling.
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- actor.SetProperty( Actor::Property::SIZE, Vector2( width, height ) );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(width, height));
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
return actor;
}
Actor CreateActorWithContent16x16()
{
- return CreateActorWithContent( 16, 16 );
+ return CreateActorWithContent(16, 16);
}
-void GenerateTrace( TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace )
+void GenerateTrace(TestApplication& application, TraceCallStack& enabledDisableTrace, TraceCallStack& stencilTrace)
{
enabledDisableTrace.Reset();
stencilTrace.Reset();
- enabledDisableTrace.Enable( true );
- stencilTrace.Enable( true );
+ enabledDisableTrace.Enable(true);
+ stencilTrace.Enable(true);
application.SendNotification();
application.Render();
- enabledDisableTrace.Enable( false );
- stencilTrace.Enable( false );
+ enabledDisableTrace.Enable(false);
+ stencilTrace.Enable(false);
}
-void CheckColorMask( TestGlAbstraction& glAbstraction, bool maskValue )
+void CheckColorMask(TestGlAbstraction& glAbstraction, bool maskValue)
{
const TestGlAbstraction::ColorMaskParams& colorMaskParams = glAbstraction.GetColorMaskParams();
- DALI_TEST_EQUALS<bool>( colorMaskParams.red, maskValue, TEST_LOCATION );
- DALI_TEST_EQUALS<bool>( colorMaskParams.green, maskValue, TEST_LOCATION );
- DALI_TEST_EQUALS<bool>( colorMaskParams.blue, maskValue, TEST_LOCATION );
- DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, maskValue, TEST_LOCATION );
+ DALI_TEST_EQUALS<bool>(colorMaskParams.red, maskValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.green, maskValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.blue, maskValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.alpha, maskValue, TEST_LOCATION);
}
int UtcDaliActorPropertyClippingP(void)
{
// This test checks the clippingMode property.
- tet_infoline( "Testing Actor::Property::ClippingMode: P" );
+ tet_infoline("Testing Actor::Property::ClippingMode: P");
TestApplication application;
Actor actor = Actor::New();
// Check default clippingEnabled value.
- Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
+ Property::Value getValue(actor.GetProperty(Actor::Property::CLIPPING_MODE));
- int value = 0;
- bool getValueResult = getValue.Get( value );
- DALI_TEST_CHECK( getValueResult );
+ int value = 0;
+ bool getValueResult = getValue.Get(value);
+ DALI_TEST_CHECK(getValueResult);
- if( getValueResult )
+ if(getValueResult)
{
- DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(value, ClippingMode::DISABLED, TEST_LOCATION);
}
// Check setting the property to the stencil mode.
- actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ actor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
// Check the new value was set.
- getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
- getValueResult = getValue.Get( value );
- DALI_TEST_CHECK( getValueResult );
+ getValue = actor.GetProperty(Actor::Property::CLIPPING_MODE);
+ getValueResult = getValue.Get(value);
+ DALI_TEST_CHECK(getValueResult);
- if( getValueResult )
+ if(getValueResult)
{
- DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(value, ClippingMode::CLIP_CHILDREN, TEST_LOCATION);
}
// Check setting the property to the scissor mode.
- actor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ actor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
// Check the new value was set.
- getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
- getValueResult = getValue.Get( value );
- DALI_TEST_CHECK( getValueResult );
+ getValue = actor.GetProperty(Actor::Property::CLIPPING_MODE);
+ getValueResult = getValue.Get(value);
+ DALI_TEST_CHECK(getValueResult);
- if( getValueResult )
+ if(getValueResult)
{
- DALI_TEST_EQUALS<int>( value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(value, ClippingMode::CLIP_TO_BOUNDING_BOX, TEST_LOCATION);
}
END_TEST;
}
int UtcDaliActorPropertyClippingN(void)
{
// Negative test case for Clipping.
- tet_infoline( "Testing Actor::Property::ClippingMode: N" );
+ tet_infoline("Testing Actor::Property::ClippingMode: N");
TestApplication application;
Actor actor = Actor::New();
// Check default clippingEnabled value.
- Property::Value getValue( actor.GetProperty( Actor::Property::CLIPPING_MODE ) );
+ Property::Value getValue(actor.GetProperty(Actor::Property::CLIPPING_MODE));
- int value = 0;
- bool getValueResult = getValue.Get( value );
- DALI_TEST_CHECK( getValueResult );
+ int value = 0;
+ bool getValueResult = getValue.Get(value);
+ DALI_TEST_CHECK(getValueResult);
- if( getValueResult )
+ if(getValueResult)
{
- DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(value, ClippingMode::DISABLED, TEST_LOCATION);
}
// Check setting an invalid property value won't change the current property value.
- actor.SetProperty( Actor::Property::CLIPPING_MODE, "INVALID_PROPERTY" );
+ actor.SetProperty(Actor::Property::CLIPPING_MODE, "INVALID_PROPERTY");
- getValue = actor.GetProperty( Actor::Property::CLIPPING_MODE );
- getValueResult = getValue.Get( value );
- DALI_TEST_CHECK( getValueResult );
+ getValue = actor.GetProperty(Actor::Property::CLIPPING_MODE);
+ getValueResult = getValue.Get(value);
+ DALI_TEST_CHECK(getValueResult);
- if( getValueResult )
+ if(getValueResult)
{
- DALI_TEST_EQUALS<int>( value, ClippingMode::DISABLED, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(value, ClippingMode::DISABLED, TEST_LOCATION);
}
END_TEST;
int UtcDaliActorPropertyClippingActor(void)
{
// This test checks that an actor is correctly setup for clipping.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor" );
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor");
TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- size_t startIndex = 0u;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ size_t startIndex = 0u;
// Create a clipping actor.
Actor actorDepth1Clip = CreateActorWithContent16x16();
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- application.GetScene().Add( actorDepth1Clip );
+ actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ application.GetScene().Add(actorDepth1Clip);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ GenerateTrace(application, enabledDisableTrace, stencilTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check the stencil buffer was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "2960")); // 2960 is GL_STENCIL_TEST
// Check the stencil buffer was cleared.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("ClearStencil", "0", startIndex));
// Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 0", startIndex ) ); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 0", startIndex)); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "1", startIndex));
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
END_TEST;
}
int UtcDaliActorPropertyClippingActorEnableThenDisable(void)
{
// This test checks that an actor is correctly setup for clipping and then correctly setup when clipping is disabled
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable" );
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN actor enable and then disable");
TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- size_t startIndex = 0u;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ size_t startIndex = 0u;
// Create a clipping actor.
Actor actorDepth1Clip = CreateActorWithContent16x16();
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- application.GetScene().Add( actorDepth1Clip );
+ actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ application.GetScene().Add(actorDepth1Clip);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ GenerateTrace(application, enabledDisableTrace, stencilTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check the stencil buffer was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "2960")); // 2960 is GL_STENCIL_TEST
// Check the stencil buffer was cleared.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("ClearStencil", "0", startIndex));
// Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 0", startIndex ) ); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) );
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 0", startIndex)); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "1", startIndex));
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
// Now disable the clipping
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
+ actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ GenerateTrace(application, enabledDisableTrace, stencilTrace);
// Check the stencil buffer was disabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Disable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Disable", "2960")); // 2960 is GL_STENCIL_TEST
// Ensure all values in stencil-mask are set to 1.
startIndex = 0u;
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "255", startIndex ) );
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "255", startIndex));
END_TEST;
}
{
// This test checks that a hierarchy of actors are clipped correctly by
// writing to and reading from the correct bit-planes of the stencil buffer.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children" );
- TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN nested children");
+ TestApplication application;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
// Create a clipping actor.
Actor actorDepth1Clip = CreateActorWithContent16x16();
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- application.GetScene().Add( actorDepth1Clip );
+ actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ application.GetScene().Add(actorDepth1Clip);
// Create a child actor.
Actor childDepth2 = CreateActorWithContent16x16();
- actorDepth1Clip.Add( childDepth2 );
+ actorDepth1Clip.Add(childDepth2);
// Create another clipping actor.
Actor childDepth2Clip = CreateActorWithContent16x16();
- childDepth2Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- childDepth2.Add( childDepth2Clip );
+ childDepth2Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ childDepth2.Add(childDepth2Clip);
// Create another 2 child actors. We do this so 2 nodes will have the same clipping ID.
// This tests the sort algorithm.
Actor childDepth3 = CreateActorWithContent16x16();
- childDepth2Clip.Add( childDepth3 );
+ childDepth2Clip.Add(childDepth3);
Actor childDepth4 = CreateActorWithContent16x16();
- childDepth3.Add( childDepth4 );
+ childDepth3.Add(childDepth4);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ GenerateTrace(application, enabledDisableTrace, stencilTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check the stencil buffer was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "2960")); // 2960 is GL_STENCIL_TEST
// Perform the test twice, once for 2D layer, and once for 3D.
- for( unsigned int i = 0u ; i < 2u; ++i )
+ for(unsigned int i = 0u; i < 2u; ++i)
{
size_t startIndex = 0u;
// Check the stencil buffer was cleared.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "ClearStencil", "0", startIndex ) );
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("ClearStencil", "0", startIndex));
// Check the correct setup was done to write to the first bit-plane (only) of the stencil buffer.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 0", startIndex ) ); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "1", startIndex ) ); // Write to the first bit-plane
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 0", startIndex)); // 514 is GL_EQUAL, But testing no bit-planes for the first clipping node.
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "1", startIndex)); // Write to the first bit-plane
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
// Check the correct setup was done to test against first bit-plane (only) of the stencil buffer.
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 1, 255", startIndex ) ); // 514 is GL_EQUAL
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 1, 255", startIndex)); // 514 is GL_EQUAL
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7680, 7680", startIndex)); // GL_KEEP, GL_KEEP, GL_KEEP
// Check we are set up to write to the second bitplane of the stencil buffer (only).
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 3, 1", startIndex ) ); // 514 is GL_EQUAL, Test both bit-planes 1 & 2
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilMask", "3", startIndex ) ); // Write to second (and previous) bit-planes
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7681, 7681", startIndex ) ); // GL_KEEP, GL_REPLACE, GL_REPLACE
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 3, 1", startIndex)); // 514 is GL_EQUAL, Test both bit-planes 1 & 2
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilMask", "3", startIndex)); // Write to second (and previous) bit-planes
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7681, 7681", startIndex)); // GL_KEEP, GL_REPLACE, GL_REPLACE
// Check we are set up to test against both the first and second bit-planes of the stencil buffer.
// (Both must be set to pass the check).
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilFunc", "514, 3, 255", startIndex ) ); // 514 is GL_EQUAL, Test both bit-planes 1 & 2
- DALI_TEST_CHECK( stencilTrace.FindMethodAndParamsFromStartIndex( "StencilOp", "7680, 7680, 7680", startIndex ) ); // GL_KEEP, GL_KEEP, GL_KEEP
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilFunc", "514, 3, 255", startIndex)); // 514 is GL_EQUAL, Test both bit-planes 1 & 2
+ DALI_TEST_CHECK(stencilTrace.FindMethodAndParamsFromStartIndex("StencilOp", "7680, 7680, 7680", startIndex)); // GL_KEEP, GL_KEEP, GL_KEEP
// If we are on the first loop, set the layer to 3D and loop to perform the test again.
- if( i == 0u )
+ if(i == 0u)
{
- application.GetScene().GetRootLayer().SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ application.GetScene().GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
+ GenerateTrace(application, enabledDisableTrace, stencilTrace);
}
}
int UtcDaliActorPropertyClippingActorDrawOrder(void)
{
// This test checks that a hierarchy of actors are drawn in the correct order when clipping is enabled.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order" );
- TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_CHILDREN draw order");
+ TestApplication application;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
/* We create a small tree of actors as follows:
The correct draw order is "ABCDE" (the same as if clipping was not enabled).
*/
Actor actors[5];
- for( int i = 0; i < 5; ++i )
+ for(int i = 0; i < 5; ++i)
{
- Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 16u, 16u );
- Actor actor = CreateRenderableActor( image );
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 16u, 16u);
+ Actor actor = CreateRenderableActor(image);
// Setup dimensions and position so actor is not skipped by culling.
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 16.0f, 16.0f ) );
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(16.0f, 16.0f));
- if( i == 0 )
+ if(i == 0)
{
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
}
else
{
float b = i > 2 ? 1.0f : -1.0f;
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3( 0.5 + ( 0.2f * b ), 0.8f, 0.8f ) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5 + (0.2f * b), 0.8f, 0.8f));
}
actors[i] = actor;
}
// Enable clipping on the actor at the top of the left branch.
- actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ actors[1].SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
// Build the scene graph.
- application.GetScene().Add( actors[0] );
+ application.GetScene().Add(actors[0]);
// Left branch:
- actors[0].Add( actors[1] );
- actors[1].Add( actors[2] );
+ actors[0].Add(actors[1]);
+ actors[1].Add(actors[2]);
// Right branch:
- actors[0].Add( actors[3] );
- actors[3].Add( actors[4] );
+ actors[0].Add(actors[3]);
+ actors[3].Add(actors[4]);
// Gather the call trace.
enabledDisableTrace.Reset();
- enabledDisableTrace.Enable( true );
+ enabledDisableTrace.Enable(true);
application.SendNotification();
application.Render();
- enabledDisableTrace.Enable( false );
+ enabledDisableTrace.Enable(false);
/* Check stencil is enabled and disabled again (as right-hand branch of tree is drawn).
Incorrect enable call trace: StackTrace: Index:0, Function:Enable, ParamList:3042 StackTrace: Index:1, Function:Enable, ParamList:2960
*/
size_t startIndex = 0u;
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable", "3042", startIndex ) );
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable", "2960", startIndex ) ); // 2960 is GL_STENCIL_TEST
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Enable", "3042", startIndex));
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Enable", "2960", startIndex)); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Disable", "2960", startIndex));
// Swap the clipping actor from top of left branch to top of right branch.
- actors[1].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED );
- actors[3].SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
+ actors[1].SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::DISABLED);
+ actors[3].SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
// Gather the call trace.
enabledDisableTrace.Reset();
- enabledDisableTrace.Enable( true );
+ enabledDisableTrace.Enable(true);
application.SendNotification();
application.Render();
- enabledDisableTrace.Enable( false );
+ enabledDisableTrace.Enable(false);
// Check stencil is enabled but NOT disabled again (as right-hand branch of tree is drawn).
// This proves the draw order has remained the same.
startIndex = 0u;
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Enable", "2960", startIndex ) );
- DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParamsFromStartIndex( "Disable", "2960", startIndex ) );
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParamsFromStartIndex("Enable", "2960", startIndex));
+ DALI_TEST_CHECK(!enabledDisableTrace.FindMethodAndParamsFromStartIndex("Disable", "2960", startIndex));
END_TEST;
}
int UtcDaliActorPropertyScissorClippingActor(void)
{
// This test checks that an actor is correctly setup for clipping.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor" );
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor");
TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
- const Vector2 imageSize( 16.0f, 16.0f );
+ const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
+ const Vector2 imageSize(16.0f, 16.0f);
// Create a clipping actor.
Actor clippingActorA = CreateActorWithContent16x16();
// Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
// We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
- clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT );
- clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
- clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
- application.GetScene().Add( clippingActorA );
+ clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT);
+ clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
+ clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+ application.GetScene().Add(clippingActorA);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, scissorTrace );
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check scissor test was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
// Check the scissor was set, and the coordinates are correct.
std::stringstream compareParametersString;
compareParametersString << "0, 0, " << imageSize.x << ", " << imageSize.y;
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) ); // Compare with 0, 0, 16, 16
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with 0, 0, 16, 16
- clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
- clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_RIGHT );
+ clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
+ clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_RIGHT);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, scissorTrace );
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
// Check the scissor was set, and the coordinates are correct.
- compareParametersString.str( std::string() );
+ compareParametersString.str(std::string());
compareParametersString.clear();
- compareParametersString << ( stageSize.x - imageSize.x ) << ", " << ( stageSize.y - imageSize.y ) << ", " << imageSize.x << ", " << imageSize.y;
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) ); // Compare with 464, 784, 16, 16
+ compareParametersString << (stageSize.x - imageSize.x) << ", " << (stageSize.y - imageSize.y) << ", " << imageSize.x << ", " << imageSize.y;
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with 464, 784, 16, 16
END_TEST;
}
int UtcDaliActorPropertyScissorClippingActorSiblings(void)
{
// This test checks that an actor is correctly setup for clipping.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings" );
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actors which are siblings");
TestApplication application;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
-
- const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
- const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
- const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
+ const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
+ const Vector2 sizeA{stageSize.width, stageSize.height * 0.25f};
+ const Vector2 sizeB{stageSize.width, stageSize.height * 0.05f};
// Create a clipping actors.
- Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
- Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
+ Actor clippingActorA = CreateActorWithContent(sizeA.width, sizeA.height);
+ Actor clippingActorB = CreateActorWithContent(sizeB.width, sizeB.height);
- clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
- clippingActorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ clippingActorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ clippingActorB.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
- clippingActorA.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, -200.0f, 0.0f ));
- clippingActorB.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
+ clippingActorA.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -200.0f, 0.0f));
+ clippingActorB.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
- application.GetScene().Add( clippingActorA );
- application.GetScene().Add( clippingActorB );
+ application.GetScene().Add(clippingActorA);
+ application.GetScene().Add(clippingActorB);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, scissorTrace );
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check scissor test was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
// Check the scissor was set, and the coordinates are correct.
std::stringstream compareParametersString;
- std::string clipA( "0, 500, 480, 200" );
- std::string clipB( "0, 380, 480, 40" );
+ std::string clipA("0, 500, 480, 200");
+ std::string clipB("0, 380, 480, 40");
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipA));
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipB));
END_TEST;
}
int UtcDaliActorPropertyScissorClippingActorNested01(void)
{
// This test checks that an actor is correctly setup for clipping.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested");
TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
- const Vector2 imageSize( 16.0f, 16.0f );
+ const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
+ const Vector2 imageSize(16.0f, 16.0f);
/* Create a nest of 2 scissors to test nesting (intersecting clips).
Actor clippingActorA = CreateActorWithContent16x16();
// Note: Scissor coords are have flipped Y values compared with DALi's coordinate system.
// We choose BOTTOM_LEFT to give us x=0, y=0 starting coordinates for the first test.
- clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
- application.GetScene().Add( clippingActorA );
+ clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+ application.GetScene().Add(clippingActorA);
// Create a child clipping actor.
Actor clippingActorB = CreateActorWithContent16x16();
- clippingActorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- clippingActorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
- clippingActorA.Add( clippingActorB );
+ clippingActorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ clippingActorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ clippingActorB.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+ clippingActorA.Add(clippingActorB);
// positionModifiers is an array of positions to position B around.
// expect is an array of expected scissor clip coordinate results.
- const Vector2 positionModifiers[4] = { Vector2( 1.0f, 1.0f ), Vector2( -1.0f, 1.0f ), Vector2( -1.0f, -1.0f ), Vector2( 1.0f, -1.0f ) };
- const Vector4 expect[4] = { Vector4( 240, 392, 8, 8 ), Vector4( 232, 392, 8, 8 ), Vector4( 232, 400, 8, 8 ), Vector4( 240, 400, 8, 8 ) };
+ const Vector2 positionModifiers[4] = {Vector2(1.0f, 1.0f), Vector2(-1.0f, 1.0f), Vector2(-1.0f, -1.0f), Vector2(1.0f, -1.0f)};
+ const Vector4 expect[4] = {Vector4(240, 392, 8, 8), Vector4(232, 392, 8, 8), Vector4(232, 400, 8, 8), Vector4(240, 400, 8, 8)};
// Loop through each overlap combination.
- for( unsigned int test = 0u; test < 4u; ++test )
+ for(unsigned int test = 0u; test < 4u; ++test)
{
// Position the child clipping actor so it intersects with the 1st clipping actor. This changes each loop.
- const Vector2 position = ( imageSize / 2.0f ) * positionModifiers[test];
- clippingActorB.SetProperty( Actor::Property::POSITION, Vector2( position.x, position.y ));
+ const Vector2 position = (imageSize / 2.0f) * positionModifiers[test];
+ clippingActorB.SetProperty(Actor::Property::POSITION, Vector2(position.x, position.y));
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, scissorTrace );
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check scissor test was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
// Check the scissor was set, and the coordinates are correct.
- const Vector4& expectResults( expect[test] );
+ const Vector4& expectResults(expect[test]);
std::stringstream compareParametersString;
compareParametersString << expectResults.x << ", " << expectResults.y << ", " << expectResults.z << ", " << expectResults.w;
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", compareParametersString.str() ) ); // Compare with the expected result
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", compareParametersString.str())); // Compare with the expected result
}
END_TEST;
int UtcDaliActorPropertyScissorClippingActorNested02(void)
{
// This test checks that an actor is correctly setup for clipping.
- tet_infoline( "Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested" );
+ tet_infoline("Testing Actor::Property::ClippingMode: CLIP_TO_BOUNDING_BOX actor nested");
TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
/* Create a nest of 2 scissors and siblings of the parent.
B E
*/
- const Vector2 stageSize( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
- const Vector2 sizeA{ stageSize.width, stageSize.height * 0.25f };
- const Vector2 sizeB{ stageSize.width, stageSize.height * 0.05f };
- const Vector2 sizeC{ stageSize.width, stageSize.height * 0.25f };
- const Vector2 sizeD{ stageSize.width, stageSize.height * 0.25f };
- const Vector2 sizeE{ stageSize.width, stageSize.height * 0.05f };
+ const Vector2 stageSize(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
+ const Vector2 sizeA{stageSize.width, stageSize.height * 0.25f};
+ const Vector2 sizeB{stageSize.width, stageSize.height * 0.05f};
+ const Vector2 sizeC{stageSize.width, stageSize.height * 0.25f};
+ const Vector2 sizeD{stageSize.width, stageSize.height * 0.25f};
+ const Vector2 sizeE{stageSize.width, stageSize.height * 0.05f};
// Create a clipping actors.
- Actor clippingActorA = CreateActorWithContent( sizeA.width, sizeA.height );
- Actor clippingActorB = CreateActorWithContent( sizeB.width, sizeB.height );
- Actor clippingActorC = CreateActorWithContent( sizeC.width, sizeC.height );
- Actor clippingActorD = CreateActorWithContent( sizeD.width, sizeD.height );
- Actor clippingActorE = CreateActorWithContent( sizeE.width, sizeE.height );
-
- clippingActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- clippingActorA.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
-
- clippingActorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- clippingActorB.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
-
- clippingActorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- clippingActorC.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
-
- clippingActorD.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorD.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- clippingActorD.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
-
- clippingActorE.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT );
- clippingActorE.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
-
- clippingActorA.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, -200.0f, 0.0f ));
- clippingActorB.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
- clippingActorC.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 100.0f, 0.0f ));
- clippingActorD.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
- clippingActorE.SetProperty( Actor::Property::POSITION, Vector3( 0.0f, 0.0f, 0.0f ));
-
- application.GetScene().Add( clippingActorA );
- clippingActorA.Add( clippingActorB );
- application.GetScene().Add( clippingActorC );
- application.GetScene().Add( clippingActorD );
- clippingActorD.Add( clippingActorE );
+ Actor clippingActorA = CreateActorWithContent(sizeA.width, sizeA.height);
+ Actor clippingActorB = CreateActorWithContent(sizeB.width, sizeB.height);
+ Actor clippingActorC = CreateActorWithContent(sizeC.width, sizeC.height);
+ Actor clippingActorD = CreateActorWithContent(sizeD.width, sizeD.height);
+ Actor clippingActorE = CreateActorWithContent(sizeE.width, sizeE.height);
+
+ clippingActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ clippingActorA.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+
+ clippingActorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ clippingActorB.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+
+ clippingActorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ clippingActorC.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+
+ clippingActorD.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorD.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ clippingActorD.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
+
+ clippingActorE.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_LEFT);
+ clippingActorE.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+
+ clippingActorA.SetProperty(Actor::Property::POSITION, Vector3(0.0f, -200.0f, 0.0f));
+ clippingActorB.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ clippingActorC.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 100.0f, 0.0f));
+ clippingActorD.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ clippingActorE.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+
+ application.GetScene().Add(clippingActorA);
+ clippingActorA.Add(clippingActorB);
+ application.GetScene().Add(clippingActorC);
+ application.GetScene().Add(clippingActorD);
+ clippingActorD.Add(clippingActorE);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, scissorTrace );
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check scissor test was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
// Check the scissor was set, and the coordinates are correct.
- std::string clipA( "0, 500, 480, 200" );
- std::string clipB( "0, 580, 480, 40" );
- std::string clipC( "0, 200, 480, 200" );
- std::string clipD( "0, 300, 480, 200" );
+ std::string clipA("0, 500, 480, 200");
+ std::string clipB("0, 580, 480, 40");
+ std::string clipC("0, 200, 480, 200");
+ std::string clipD("0, 300, 480, 200");
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipA ) );
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipB ) );
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipC ) );
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", clipD ) );
- DALI_TEST_CHECK( scissorTrace.CountMethod( "Scissor" ) == 4 ); // Scissor rect should not be changed in clippingActorE case. So count should be 4.
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipA));
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipB));
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipC));
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", clipD));
+ DALI_TEST_CHECK(scissorTrace.CountMethod("Scissor") == 4); // Scissor rect should not be changed in clippingActorE case. So count should be 4.
END_TEST;
}
int UtcDaliActorPropertyClippingActorWithRendererOverride(void)
{
// This test checks that an actor with clipping will be ignored if overridden by the Renderer properties.
- tet_infoline( "Testing Actor::Property::CLIPPING_MODE actor with renderer override" );
+ tet_infoline("Testing Actor::Property::CLIPPING_MODE actor with renderer override");
TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& stencilTrace = glAbstraction.GetStencilFunctionTrace();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
// Create a clipping actor.
Actor actorDepth1Clip = CreateActorWithContent16x16();
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- application.GetScene().Add( actorDepth1Clip );
+ actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ application.GetScene().Add(actorDepth1Clip);
// Turn the RenderMode to just "COLOR" at the Renderer level to ignore the clippingMode.
- actorDepth1Clip.GetRendererAt( 0 ).SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
+ actorDepth1Clip.GetRendererAt(0).SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, stencilTrace );
+ GenerateTrace(application, enabledDisableTrace, stencilTrace);
// Check we are writing to the color buffer.
- CheckColorMask( glAbstraction, true );
+ CheckColorMask(glAbstraction, true);
// Check the stencil buffer was not enabled.
- DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "2960" ) ); // 2960 is GL_STENCIL_TEST
+ DALI_TEST_CHECK(!enabledDisableTrace.FindMethodAndParams("Enable", "2960")); // 2960 is GL_STENCIL_TEST
// Check stencil functions are not called.
- DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilFunc" ) );
- DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilMask" ) );
- DALI_TEST_CHECK( !stencilTrace.FindMethod( "StencilOp" ) );
+ DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilFunc"));
+ DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilMask"));
+ DALI_TEST_CHECK(!stencilTrace.FindMethod("StencilOp"));
// Check that scissor clipping is overriden by the renderer properties.
TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
- actorDepth1Clip.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX );
+ actorDepth1Clip.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_TO_BOUNDING_BOX);
// Gather the call trace.
- GenerateTrace( application, enabledDisableTrace, scissorTrace );
+ GenerateTrace(application, enabledDisableTrace, scissorTrace);
// Check the stencil buffer was not enabled.
- DALI_TEST_CHECK( !enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+ DALI_TEST_CHECK(!enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
- DALI_TEST_CHECK( !scissorTrace.FindMethod( "StencilFunc" ) );
+ DALI_TEST_CHECK(!scissorTrace.FindMethod("StencilFunc"));
END_TEST;
}
int UtcDaliGetPropertyN(void)
{
- tet_infoline( "Testing Actor::GetProperty returns a non valid value if property index is out of range" );
+ tet_infoline("Testing Actor::GetProperty returns a non valid value if property index is out of range");
TestApplication application;
Actor actor = Actor::New();
unsigned int propertyCount = actor.GetPropertyCount();
- DALI_TEST_EQUALS( actor.GetProperty( Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Property::Index(propertyCount)).GetType(), Property::NONE, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorRaiseLower(void)
{
- tet_infoline( "UtcDaliActor Raise and Lower test\n" );
+ tet_infoline("UtcDaliActor Raise and Lower test\n");
TestApplication application;
- Debug::Filter::SetGlobalLogLevel( Debug::Verbose );
+ Debug::Filter::SetGlobalLogLevel(Debug::Verbose);
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorC = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- stage.Add( actorA );
- stage.Add( actorB );
- stage.Add( actorC );
+ stage.Add(actorA);
+ stage.Add(actorB);
+ stage.Add(actorC);
ResetTouchCallbacks();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Testing Raising of Actor\n" );
+ tet_printf("Testing Raising of Actor\n");
- int preActorOrder( 0 );
- int postActorOrder( 0 );
+ int preActorOrder(0);
+ int postActorOrder(0);
- Property::Value value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- value.Get( preActorOrder );
+ Property::Value value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
+ value.Get(preActorOrder);
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.Raise();
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
// Ensure sort order is calculated before next touch event
application.SendNotification();
- value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- value.Get( postActorOrder );
+ value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
+ value.Get(postActorOrder);
- tet_printf( "Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
+ tet_printf("Raised ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true , TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Testing Lowering of Actor\n" );
+ tet_printf("Testing Lowering of Actor\n");
- value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- value.Get( preActorOrder );
+ value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
+ value.Get(preActorOrder);
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.Lower();
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
application.SendNotification(); // ensure sort order calculated before next touch event
- value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER );
- value.Get( postActorOrder );
+ value = actorB.GetProperty(Dali::DevelActor::Property::SIBLING_ORDER);
+ value.Get(postActorOrder);
- tet_printf( "Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder );
+ tet_printf("Lowered ActorB from (%d) to (%d) \n", preActorOrder, postActorOrder);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false , TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- Debug::Filter::SetGlobalLogLevel( Debug::NoLogging );
+ Debug::Filter::SetGlobalLogLevel(Debug::NoLogging);
END_TEST;
}
int UtcDaliActorRaiseToTopLowerToBottom(void)
{
- tet_infoline( "UtcDaliActorRaiseToTop and LowerToBottom test \n" );
+ tet_infoline("UtcDaliActorRaiseToTop and LowerToBottom test \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
// Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
// enables checking of which actor the uniform is assigned too
Shader shaderA = CreateShader();
- shaderA.RegisterProperty( "uRendererColor",1.f);
+ shaderA.RegisterProperty("uRendererColor", 1.f);
Shader shaderB = CreateShader();
- shaderB.RegisterProperty( "uRendererColor", 2.f );
+ shaderB.RegisterProperty("uRendererColor", 2.f);
Shader shaderC = CreateShader();
- shaderC.RegisterProperty( "uRendererColor", 3.f );
+ shaderC.RegisterProperty("uRendererColor", 3.f);
Geometry geometry = CreateQuadGeometry();
Renderer rendererC = Renderer::New(geometry, shaderC);
actorC.AddRenderer(rendererC);
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- stage.Add( actorA );
- stage.Add( actorB );
- stage.Add( actorC );
+ stage.Add(actorA);
+ stage.Add(actorB);
+ stage.Add(actorC);
ResetTouchCallbacks();
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
// Set up gl abstraction trace so can query the set uniform order
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
application.SendNotification();
application.Render();
- tet_printf( "Trace Output:%s \n", glSetUniformStack.GetTraceString().c_str() );
-
+ tet_printf("Trace Output:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ int indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ int indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ int indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- bool CBA = ( indexC > indexB) && ( indexB > indexA );
+ bool CBA = (indexC > indexB) && (indexB > indexA);
- DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(CBA, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "RaiseToTop ActorA\n" );
+ tet_printf("RaiseToTop ActorA\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorA.RaiseToTop();
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
application.SendNotification(); // ensure sorting order is calculated before next touch event
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
glAbstraction.ResetSetUniformCallStack();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
application.SendNotification();
application.Render();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- tet_infoline( "Testing A above C and B at bottom\n" );
- bool ACB = ( indexA > indexC) && ( indexC > indexB );
+ tet_infoline("Testing A above C and B at bottom\n");
+ bool ACB = (indexA > indexC) && (indexC > indexB);
- DALI_TEST_EQUALS( ACB, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(ACB, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "RaiseToTop ActorB\n" );
+ tet_printf("RaiseToTop ActorB\n");
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.RaiseToTop();
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
application.SendNotification(); // Ensure sort order is calculated before next touch event
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
glAbstraction.ResetSetUniformCallStack();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
application.SendNotification();
application.Render();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- tet_infoline( "Testing B above A and C at bottom\n" );
- bool BAC = ( indexB > indexA ) && ( indexA > indexC );
+ tet_infoline("Testing B above A and C at bottom\n");
+ bool BAC = (indexB > indexA) && (indexA > indexC);
- DALI_TEST_EQUALS( BAC, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(BAC, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "LowerToBottom ActorA then ActorB leaving Actor C at Top\n" );
+ tet_printf("LowerToBottom ActorA then ActorB leaving Actor C at Top\n");
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorA.LowerToBottom();
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
application.SendNotification();
application.Render();
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.LowerToBottom();
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
glAbstraction.ResetSetUniformCallStack();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
application.SendNotification();
application.Render();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- tet_infoline( "Testing C above A and B at bottom\n" );
- bool CAB = ( indexC > indexA ) && ( indexA > indexB );
+ tet_infoline("Testing C above A and B at bottom\n");
+ bool CAB = (indexC > indexA) && (indexA > indexB);
- DALI_TEST_EQUALS( CAB, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(CAB, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
int UtcDaliActorRaiseAbove(void)
{
- tet_infoline( "UtcDaliActor RaiseToAbove test \n" );
+ tet_infoline("UtcDaliActor RaiseToAbove test \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorC = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- stage.Add( actorA );
- stage.Add( actorB );
- stage.Add( actorC );
+ stage.Add(actorA);
+ stage.Add(actorB);
+ stage.Add(actorC);
ResetTouchCallbacks();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Raise actor B Above Actor C\n" );
+ tet_printf("Raise actor B Above Actor C\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorB.RaiseAbove( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorB.RaiseAbove(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Raise actor A Above Actor B\n" );
+ tet_printf("Raise actor A Above Actor B\n");
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.RaiseAbove( actorB );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.RaiseAbove(actorB);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
- application.ProcessEvent( touchEvent ); // process a touch event on ordered actors.
+ application.ProcessEvent(touchEvent); // process a touch event on ordered actors.
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
int UtcDaliActorLowerBelow(void)
{
- tet_infoline( "UtcDaliActor LowerBelow test \n" );
+ tet_infoline("UtcDaliActor LowerBelow test \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
// Set up renderers to add to Actors, float value 1, 2, 3 assigned to each
// enables checking of which actor the uniform is assigned too
Shader shaderA = CreateShader();
- shaderA.RegisterProperty( "uRendererColor",1.f);
+ shaderA.RegisterProperty("uRendererColor", 1.f);
Shader shaderB = CreateShader();
- shaderB.RegisterProperty( "uRendererColor", 2.f );
+ shaderB.RegisterProperty("uRendererColor", 2.f);
Shader shaderC = CreateShader();
- shaderC.RegisterProperty( "uRendererColor", 3.f );
+ shaderC.RegisterProperty("uRendererColor", 3.f);
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Renderer rendererC = Renderer::New(geometry, shaderC);
actorC.AddRenderer(rendererC);
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
Actor container = Actor::New();
- container.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- container.SetResizePolicy( ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS );
- stage.Add( container );
+ container.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ container.SetResizePolicy(ResizePolicy::FILL_TO_PARENT, Dimension::ALL_DIMENSIONS);
+ stage.Add(container);
- container.Add( actorA );
- container.Add( actorB );
- container.Add( actorC );
+ container.Add(actorA);
+ container.Add(actorB);
+ container.Add(actorC);
ResetTouchCallbacks();
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( container ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(container).Connect(&application, f);
// Set up gl abstraction trace so can query the set uniform order
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- int indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- int indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- int indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ int indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ int indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ int indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- tet_infoline( "Testing C above B and A at bottom\n" );
- bool CBA = ( indexC > indexB) && ( indexB > indexA );
+ tet_infoline("Testing C above B and A at bottom\n");
+ bool CBA = (indexC > indexB) && (indexB > indexA);
- DALI_TEST_EQUALS( CBA, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(CBA, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- tet_infoline( "UtcDaliActor Test Set up completed \n" );
+ tet_infoline("UtcDaliActor Test Set up completed \n");
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Lower actor C below Actor B ( actor B and A on same level due to insertion order) so C is below both \n" );
+ tet_printf("Lower actor C below Actor B ( actor B and A on same level due to insertion order) so C is below both \n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorC.LowerBelow( actorB );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorC.LowerBelow(actorB);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorC, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent ); // touch event
+ application.ProcessEvent(touchEvent); // touch event
glAbstraction.ResetSetUniformCallStack();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
application.SendNotification();
application.Render();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- tet_infoline( "Testing render order is A, C, B" );
- DALI_TEST_EQUALS( indexC > indexA, true, TEST_LOCATION );
- DALI_TEST_EQUALS( indexB > indexC, true, TEST_LOCATION );
+ tet_infoline("Testing render order is A, C, B");
+ DALI_TEST_EQUALS(indexC > indexA, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(indexB > indexC, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Lower actor C below Actor A leaving B on top\n" );
+ tet_printf("Lower actor C below Actor A leaving B on top\n");
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorC.LowerBelow( actorA );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorC, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorC.LowerBelow(actorA);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorC, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
glAbstraction.ResetSetUniformCallStack();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
application.Render();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
- DALI_TEST_EQUALS( indexB > indexA, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(indexA > indexC, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(indexB > indexA, true, TEST_LOCATION);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Lower actor B below Actor C leaving A on top\n" );
+ tet_printf("Lower actor B below Actor C leaving A on top\n");
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorB.LowerBelow( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorB, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorB.LowerBelow(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorB, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
glAbstraction.ResetSetUniformCallStack();
glSetUniformStack = glAbstraction.GetSetUniformTrace();
application.Render();
- tet_printf( "Trace:%s \n", glSetUniformStack.GetTraceString().c_str() );
+ tet_printf("Trace:%s \n", glSetUniformStack.GetTraceString().c_str());
// Test order of uniforms in stack
- indexC = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "3" );
- indexB = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "2" );
- indexA = glSetUniformStack.FindIndexFromMethodAndParams( "uRendererColor", "1" );
+ indexC = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "3");
+ indexB = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "2");
+ indexA = glSetUniformStack.FindIndexFromMethodAndParams("uRendererColor", "1");
- DALI_TEST_EQUALS( indexC > indexB, true, TEST_LOCATION );
- DALI_TEST_EQUALS( indexA > indexC, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(indexC > indexB, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(indexA > indexC, true, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliActorRaiseAboveDifferentParentsN(void)
{
- tet_infoline( "UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n" );
+ tet_infoline("UtcDaliActor RaiseToAbove test with actor and target actor having different parents \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor parentA = Actor::New();
Actor parentB = Actor::New();
- parentA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- parentA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
- parentB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- parentB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ parentA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ parentA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
+ parentB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ parentB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- parentA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- parentA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ parentA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ parentA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- parentB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- parentB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ parentB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ parentB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- stage.Add( parentA );
- stage.Add( parentB );
+ stage.Add(parentA);
+ stage.Add(parentB);
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorC = Actor::New();
- parentA.Add( actorA );
- parentA.Add( actorB );
+ parentA.Add(actorA);
+ parentA.Add(actorB);
- tet_printf( "Actor C added to different parent from A and B \n" );
- parentB.Add( actorC );
+ tet_printf("Actor C added to different parent from A and B \n");
+ parentB.Add(actorC);
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
ResetTouchCallbacks();
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- tet_printf( "Raise actor A Above Actor C which have different parents\n" );
+ tet_printf("Raise actor A Above Actor C which have different parents\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.RaiseAbove( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.RaiseAbove(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
- application.ProcessEvent( touchEvent ); // touch event
+ application.ProcessEvent(touchEvent); // touch event
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
int UtcDaliActorRaiseLowerWhenUnparentedTargetN(void)
{
- tet_infoline( "UtcDaliActor Test raiseAbove and lowerBelow api when target Actor has no parent \n" );
+ tet_infoline("UtcDaliActor Test raiseAbove and lowerBelow api when target Actor has no parent \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorC = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
ResetTouchCallbacks();
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- tet_printf( "Raise actor A Above Actor C which have no parents\n" );
+ tet_printf("Raise actor A Above Actor C which have no parents\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.RaiseAbove( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.RaiseAbove(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Not parented so RaiseAbove should show no effect\n" );
+ tet_printf("Not parented so RaiseAbove should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- stage.Add ( actorB );
- tet_printf( "Lower actor A below Actor C when only A is not on stage \n" );
+ stage.Add(actorB);
+ tet_printf("Lower actor A below Actor C when only A is not on stage \n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.LowerBelow( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.LowerBelow(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Actor A not parented so LowerBelow should show no effect\n" );
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ tet_printf("Actor A not parented so LowerBelow should show no effect\n");
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- tet_printf( "Adding Actor A to stage, will be on top\n" );
+ tet_printf("Adding Actor A to stage, will be on top\n");
- stage.Add ( actorA );
+ stage.Add(actorA);
application.SendNotification();
application.Render();
- tet_printf( "Raise actor B Above Actor C when only B has a parent\n" );
+ tet_printf("Raise actor B Above Actor C when only B has a parent\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorB.RaiseAbove( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorB.RaiseAbove(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "C not parented so RaiseAbove should show no effect\n" );
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ tet_printf("C not parented so RaiseAbove should show no effect\n");
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- tet_printf( "Lower actor A below Actor C when only A has a parent\n" );
+ tet_printf("Lower actor A below Actor C when only A has a parent\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.LowerBelow( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.LowerBelow(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "C not parented so LowerBelow should show no effect\n" );
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ tet_printf("C not parented so LowerBelow should show no effect\n");
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- stage.Add ( actorC );
+ stage.Add(actorC);
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.RaiseAbove( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.RaiseAbove(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
// Ensure sorting happens at end of Core::ProcessEvents() before next touch
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Raise actor A Above Actor C, now both have same parent \n" );
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ tet_printf("Raise actor A Above Actor C, now both have same parent \n");
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorTestAllAPIwhenActorNotParented(void)
{
- tet_infoline( "UtcDaliActor Test all raise/lower api when actor has no parent \n" );
+ tet_infoline("UtcDaliActor Test all raise/lower api when actor has no parent \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorC = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
ResetTouchCallbacks();
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- stage.Add ( actorA );
- tet_printf( "Raise actor B Above Actor C but B not parented\n" );
+ stage.Add(actorA);
+ tet_printf("Raise actor B Above Actor C but B not parented\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.Raise();
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Not parented so RaiseAbove should show no effect\n" );
+ tet_printf("Not parented so RaiseAbove should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
- tet_printf( "Raise actor B Above Actor C but B not parented\n" );
+ tet_printf("Raise actor B Above Actor C but B not parented\n");
ResetTouchCallbacks();
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorC.Lower();
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Sort actor tree before next touch event
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Not parented so RaiseAbove should show no effect\n" );
+ tet_printf("Not parented so RaiseAbove should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- tet_printf( "Lower actor C below B but C not parented\n" );
+ tet_printf("Lower actor C below B but C not parented\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.Lower();
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Sort actor tree before next touch event
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Not parented so Lower should show no effect\n" );
+ tet_printf("Not parented so Lower should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- tet_printf( "Raise actor B to top\n" );
+ tet_printf("Raise actor B to top\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorB.RaiseToTop();
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
// Sort actor tree before next touch event
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Not parented so RaiseToTop should show no effect\n" );
+ tet_printf("Not parented so RaiseToTop should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- tet_printf( "Add ActorB to stage so only Actor C not parented\n" );
+ tet_printf("Add ActorB to stage so only Actor C not parented\n");
- stage.Add ( actorB );
+ stage.Add(actorB);
- tet_printf( "Lower actor C to Bottom, B stays at top\n" );
+ tet_printf("Lower actor C to Bottom, B stays at top\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
actorC.LowerToBottom();
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_printf( "Not parented so LowerToBottom should show no effect\n" );
+ tet_printf("Not parented so LowerToBottom should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
ResetTouchCallbacks();
END_TEST;
}
-
int UtcDaliActorRaiseAboveActorAndTargetTheSameN(void)
{
- tet_infoline( "UtcDaliActor RaiseToAbove and test with actor provided as target resulting in a no operation \n" );
+ tet_infoline("UtcDaliActor RaiseToAbove and test with actor provided as target resulting in a no operation \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
Actor actorB = Actor::New();
Actor actorC = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- actorA.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorA.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorA.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorA.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorB.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorB.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorB.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorB.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- actorC.SetProperty( Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT" );
- actorC.SetProperty( Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT" );
+ actorC.SetProperty(Actor::Property::WIDTH_RESIZE_POLICY, "FILL_TO_PARENT");
+ actorC.SetProperty(Actor::Property::HEIGHT_RESIZE_POLICY, "FILL_TO_PARENT");
- stage.Add( actorA );
- stage.Add( actorB );
- stage.Add( actorC );
+ stage.Add(actorA);
+ stage.Add(actorB);
+ stage.Add(actorC);
// connect to actor touch signals, will use touch callbacks to determine which actor is on top.
// Only top actor will get touched.
- actorA.TouchedSignal().Connect( TestTouchCallback );
- actorB.TouchedSignal().Connect( TestTouchCallback2 );
- actorC.TouchedSignal().Connect( TestTouchCallback3 );
+ actorA.TouchedSignal().Connect(TestTouchCallback);
+ actorB.TouchedSignal().Connect(TestTouchCallback2);
+ actorC.TouchedSignal().Connect(TestTouchCallback3);
ResetTouchCallbacks();
// Connect ChildOrderChangedSignal
- bool orderChangedSignal( false );
- Actor orderChangedActor;
- ChildOrderChangedFunctor f( orderChangedSignal, orderChangedActor );
- DevelActor::ChildOrderChangedSignal( stage.GetRootLayer() ).Connect( &application, f ) ;
+ bool orderChangedSignal(false);
+ Actor orderChangedActor;
+ ChildOrderChangedFunctor f(orderChangedSignal, orderChangedActor);
+ DevelActor::ChildOrderChangedSignal(stage.GetRootLayer()).Connect(&application, f);
application.SendNotification();
application.Render();
Dali::Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.f, 10.f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.f, 10.f));
Dali::Integration::TouchEvent touchEvent;
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
- tet_infoline( "Raise actor A Above Actor A which is the same actor!!\n" );
+ tet_infoline("Raise actor A Above Actor A which is the same actor!!\n");
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.RaiseAbove( actorA );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.RaiseAbove(actorA);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_infoline( "No target is source Actor so RaiseAbove should show no effect\n" );
+ tet_infoline("No target is source Actor so RaiseAbove should show no effect\n");
- DALI_TEST_EQUALS( gTouchCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, true , TEST_LOCATION );
+ DALI_TEST_EQUALS(gTouchCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, true, TEST_LOCATION);
ResetTouchCallbacks();
orderChangedSignal = false;
- DALI_TEST_EQUALS( orderChangedSignal, false, TEST_LOCATION );
- actorA.RaiseAbove( actorC );
- DALI_TEST_EQUALS( orderChangedSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( orderChangedActor, actorA, TEST_LOCATION );
+ DALI_TEST_EQUALS(orderChangedSignal, false, TEST_LOCATION);
+ actorA.RaiseAbove(actorC);
+ DALI_TEST_EQUALS(orderChangedSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(orderChangedActor, actorA, TEST_LOCATION);
application.SendNotification();
application.Render();
- application.ProcessEvent( touchEvent );
+ application.ProcessEvent(touchEvent);
- tet_infoline( "Raise actor A Above Actor C which will now be successful \n" );
- DALI_TEST_EQUALS( gTouchCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled2, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gTouchCallBackCalled3, false , TEST_LOCATION );
+ tet_infoline("Raise actor A Above Actor C which will now be successful \n");
+ DALI_TEST_EQUALS(gTouchCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled2, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gTouchCallBackCalled3, false, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorGetScreenPosition(void)
{
- tet_infoline( "UtcDaliActorGetScreenPosition Get screen coordinates of Actor \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Get screen coordinates of Actor \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
- Vector2 size2( 10.0f, 20.0f );
- actorA.SetProperty( Actor::Property::SIZE, size2 );
+ Vector2 size2(10.0f, 20.0f);
+ actorA.SetProperty(Actor::Property::SIZE, size2);
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Center Anchor Point and 0,0 position \n");
- stage.Add( actorA );
+ stage.Add(actorA);
application.SendNotification();
application.Render();
- Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ Vector3 actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::CENTER \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position %f %f \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
- tet_infoline( "UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Top Left Anchor Point and 0,0 position \n");
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
- tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Bottom right Anchor Point and 0,0 position \n");
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
- tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,0 position \n");
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 30.0, 0.0 ));
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(30.0, 0.0));
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 0.0 \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 30lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 30lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
- tet_infoline( "UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Bottom right Anchor Point and 30,420 position \n");
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 30.0, 420.0 ));
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(30.0, 420.0));
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- DALI_TEST_EQUALS( actorScreenPosition.x, 30lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 420lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 30lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 420lu, TEST_LOCATION);
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0\n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position( %f %f ) AnchorPoint::BOTTOM_RIGHT Position x=30 y = 420.0 \n", actorScreenPosition.x, actorScreenPosition.y);
- tet_infoline( "UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n" );
+ tet_infoline("UtcDaliActorGetScreenPosition Scale parent and check child's screen position \n");
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 30.0, 30.0 ));
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(30.0, 30.0));
Actor actorB = Actor::New();
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorB.SetProperty( Actor::Property::SIZE, size2 );
- actorB.SetProperty( Actor::Property::POSITION, Vector2( 10.f, 10.f ));
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorB.SetProperty(Actor::Property::SIZE, size2);
+ actorB.SetProperty(Actor::Property::POSITION, Vector2(10.f, 10.f));
+ actorA.Add(actorB);
- actorA.SetProperty( Actor::Property::SCALE, 2.0f );
+ actorA.SetProperty(Actor::Property::SCALE, 2.0f);
application.SendNotification();
application.Render();
- actorScreenPosition = actorB.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorScreenPosition = actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- DALI_TEST_EQUALS( actorScreenPosition.x, 50lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 50lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 50lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 50lu, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorGetScreenPositionAfterScaling(void)
{
- tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling Get screen coordinates of Actor \n" );
+ tet_infoline("UtcDaliActorGetScreenPositionAfterScaling Get screen coordinates of Actor \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
- Vector2 size2( 10.0f, 20.0f );
- actorA.SetProperty( Actor::Property::SIZE, size2 );
- actorA.SetProperty( Actor::Property::SCALE, 1.5f );
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ Vector2 size2(10.0f, 20.0f);
+ actorA.SetProperty(Actor::Property::SIZE, size2);
+ actorA.SetProperty(Actor::Property::SCALE, 1.5f);
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPositionAfterScaling TopRight Anchor Point, scale 1.5f and 0,0 position \n");
- stage.Add( actorA );
+ stage.Add(actorA);
application.SendNotification();
application.Render();
- Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ Vector3 actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 0lu , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0lu , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 0lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0lu, TEST_LOCATION);
- tet_infoline( "UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n" );
+ tet_infoline("UtcDaliActorGetScreenPositionAfterScaling BOTTOM_RIGHT Anchor Point, scale 1.5f and 0,0 position \n");
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x , 0.0f , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorGetScreenPositionWithDifferentParentOrigin(void)
{
- tet_infoline( "UtcDaliActorGetScreenPositionWithDifferentParentOrigin Changes parent origin which should not effect result \n" );
+ tet_infoline("UtcDaliActorGetScreenPositionWithDifferentParentOrigin Changes parent origin which should not effect result \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- Vector2 size2( 10.0f, 20.0f );
- actorA.SetProperty( Actor::Property::SIZE, size2 );
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Vector2 size2(10.0f, 20.0f);
+ actorA.SetProperty(Actor::Property::SIZE, size2);
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( " TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+ tet_infoline(" TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
- stage.Add( actorA );
+ stage.Add(actorA);
application.SendNotification();
application.Render();
- Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ Vector3 actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 240.0f , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 400.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 240.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 400.0f, TEST_LOCATION);
- tet_infoline( " BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n" );
+ tet_infoline(" BOTTOM_RIGHT Anchor Point, ParentOrigin::TOP_RIGHT and 0,0 position \n");
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_RIGHT ParentOrigin::TOP_RIGHT \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x , 480.0f , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 0.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 480.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 0.0f, TEST_LOCATION);
END_TEST;
END_TEST;
int UtcDaliActorGetScreenPositionWithChildActors(void)
{
- tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors Check screen position with a tree of actors \n" );
+ tet_infoline("UtcDaliActorGetScreenPositionWithChildActors Check screen position with a tree of actors \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
- tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+ tet_infoline("Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- Vector2 size1( 10.0f, 20.0f );
- actorA.SetProperty( Actor::Property::SIZE, size1 );
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Vector2 size1(10.0f, 20.0f);
+ actorA.SetProperty(Actor::Property::SIZE, size1);
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+ tet_infoline("Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
Actor parentActorA = Actor::New();
- parentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- parentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- Vector2 size2( 30.0f, 60.0f );
- parentActorA.SetProperty( Actor::Property::SIZE, size2 );
- parentActorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ parentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ parentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Vector2 size2(30.0f, 60.0f);
+ parentActorA.SetProperty(Actor::Property::SIZE, size2);
+ parentActorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
+ tet_infoline("Add child 1 to Parent 1 and check screen position \n");
- stage.Add( parentActorA );
- parentActorA.Add ( actorA );
+ stage.Add(parentActorA);
+ parentActorA.Add(actorA);
application.SendNotification();
application.Render();
- Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ Vector3 actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 255.0f , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 430.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 255.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 430.0f, TEST_LOCATION);
- tet_infoline( "Test 2\n");
+ tet_infoline("Test 2\n");
- tet_infoline( "change parent anchor point and parent origin then check screen position \n" );
+ tet_infoline("change parent anchor point and parent origin then check screen position \n");
- parentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
- parentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
+ parentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
+ parentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
application.SendNotification();
application.Render();
- actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::BOTTOM_LEFT ParentOrigin::TOP_LEFT \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 15.0f , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, -30.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 15.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, -30.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorGetScreenPositionWithChildActors02(void)
{
- tet_infoline( "UtcDaliActorGetScreenPositionWithChildActors02 Check screen position with a tree of actors \n" );
+ tet_infoline("UtcDaliActorGetScreenPositionWithChildActors02 Check screen position with a tree of actors \n");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
- tet_infoline( "Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+ tet_infoline("Create Child Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- Vector2 size1( 10.0f, 20.0f );
- actorA.SetProperty( Actor::Property::SIZE, size1 );
- actorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Vector2 size1(10.0f, 20.0f);
+ actorA.SetProperty(Actor::Property::SIZE, size1);
+ actorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n" );
+ tet_infoline("Create Parent Actor 1 TOP_LEFT Anchor Point, ParentOrigin::CENTER and 0,0 position \n");
Actor parentActorA = Actor::New();
- parentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- parentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- Vector2 size2( 30.0f, 60.0f );
- parentActorA.SetProperty( Actor::Property::SIZE, size2 );
- parentActorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ parentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ parentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ Vector2 size2(30.0f, 60.0f);
+ parentActorA.SetProperty(Actor::Property::SIZE, size2);
+ parentActorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n" );
+ tet_infoline("Create Grand Parent Actor 1 BOTTOM_LEFT Anchor Point, ParentOrigin::BOTTOM_LEFT and 0,0 position \n");
Actor grandParentActorA = Actor::New();
- grandParentActorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
- grandParentActorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT );
- Vector2 size3( 60.0f, 120.0f );
- grandParentActorA.SetProperty( Actor::Property::SIZE, size3 );
- grandParentActorA.SetProperty( Actor::Property::POSITION, Vector2( 0.f, 0.f ));
+ grandParentActorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
+ grandParentActorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT);
+ Vector2 size3(60.0f, 120.0f);
+ grandParentActorA.SetProperty(Actor::Property::SIZE, size3);
+ grandParentActorA.SetProperty(Actor::Property::POSITION, Vector2(0.f, 0.f));
- tet_infoline( "Add Parent 1 to Grand Parent 1 \n" );
+ tet_infoline("Add Parent 1 to Grand Parent 1 \n");
- stage.Add( grandParentActorA );
- grandParentActorA.Add ( parentActorA );
+ stage.Add(grandParentActorA);
+ grandParentActorA.Add(parentActorA);
- tet_infoline( "Add child 1 to Parent 1 and check screen position \n" );
+ tet_infoline("Add child 1 to Parent 1 and check screen position \n");
- parentActorA.Add ( actorA );
+ parentActorA.Add(actorA);
application.SendNotification();
application.Render();
- Vector3 actorWorldPosition = actorA.GetProperty( Actor::Property::WORLD_POSITION ).Get< Vector3 >();
- Vector2 actorScreenPosition = actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >();
+ Vector3 actorWorldPosition = actorA.GetProperty(Actor::Property::WORLD_POSITION).Get<Vector3>();
+ Vector2 actorScreenPosition = actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>();
- tet_printf( "Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y );
- tet_printf( "Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y );
+ tet_printf("Actor World Position ( %f %f ) AnchorPoint::TOP_LEFT ParentOrigin::CENTER \n", actorWorldPosition.x, actorWorldPosition.y);
+ tet_printf("Actor Screen Position ( %f %f ) \n", actorScreenPosition.x, actorScreenPosition.y);
- DALI_TEST_EQUALS( actorScreenPosition.x, 45.0f , TEST_LOCATION );
- DALI_TEST_EQUALS( actorScreenPosition.y, 770.0f , TEST_LOCATION );
+ DALI_TEST_EQUALS(actorScreenPosition.x, 45.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorScreenPosition.y, 770.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse(void)
{
- tet_infoline( "UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse Check screen position where the position does not use the anchor point" );
+ tet_infoline("UtcDaliActorGetScreenPositionPositionUsesAnchorPointFalse Check screen position where the position does not use the anchor point");
TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ Integration::Scene stage(application.GetScene());
- tet_infoline( "Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
+ tet_infoline("Create an actor with AnchorPoint::TOP_LEFT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false");
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actorA.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- actorA.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 20.0f ) );
- stage.Add( actorA );
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actorA.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ actorA.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 20.0f));
+ stage.Add(actorA);
- tet_infoline( "Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
+ tet_infoline("Create an Actor with AnchorPoint::BOTTOM_RIGHT, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false");
Actor actorB = Actor::New();
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actorB.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- Vector2 actorBSize( 30.0f, 60.0f );
- actorB.SetProperty( Actor::Property::SIZE, actorBSize );
- stage.Add( actorB );
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actorB.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ Vector2 actorBSize(30.0f, 60.0f);
+ actorB.SetProperty(Actor::Property::SIZE, actorBSize);
+ stage.Add(actorB);
- tet_infoline( "Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false" );
+ tet_infoline("Create an actor with AnchorPoint::CENTER, ParentOrigin::CENTER and 0,0 position, POSITION_USES_ANCHOR false");
Actor actorC = Actor::New();
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actorC.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- Vector2 actorCSize( 60.0f, 120.0f );
- actorC.SetProperty( Actor::Property::SIZE, actorCSize );
- stage.Add( actorC );
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actorC.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ Vector2 actorCSize(60.0f, 120.0f);
+ actorC.SetProperty(Actor::Property::SIZE, actorCSize);
+ stage.Add(actorC);
application.SendNotification();
application.Render();
- tet_infoline( "Despite differing sizes and anchor-points, the screen position for all actors is the same");
+ tet_infoline("Despite differing sizes and anchor-points, the screen position for all actors is the same");
- Vector2 center( stage.GetSize() * 0.5f );
+ Vector2 center(stage.GetSize() * 0.5f);
- DALI_TEST_EQUALS( actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
- DALI_TEST_EQUALS( actorB.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
- DALI_TEST_EQUALS( actorC.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center, TEST_LOCATION );
+ DALI_TEST_EQUALS(actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorC.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center, TEST_LOCATION);
- tet_infoline( "Add scale to all actors" );
+ tet_infoline("Add scale to all actors");
- actorA.SetProperty( Actor::Property::SCALE, 2.0f );
- actorB.SetProperty( Actor::Property::SCALE, 2.0f );
- actorC.SetProperty( Actor::Property::SCALE, 2.0f );
+ actorA.SetProperty(Actor::Property::SCALE, 2.0f);
+ actorB.SetProperty(Actor::Property::SCALE, 2.0f);
+ actorC.SetProperty(Actor::Property::SCALE, 2.0f);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actorA.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center /* TOP_LEFT Anchor */, TEST_LOCATION );
- DALI_TEST_EQUALS( actorB.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION );
- DALI_TEST_EQUALS( actorC.GetProperty( Actor::Property::SCREEN_POSITION).Get< Vector2 >(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actorA.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center /* TOP_LEFT Anchor */, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorB.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center - actorBSize /* BOTTOM_RIGHT Anchor */, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorC.GetProperty(Actor::Property::SCREEN_POSITION).Get<Vector2>(), center - actorCSize * 0.5f /* CENTER Anchor*/, TEST_LOCATION);
END_TEST;
}
int utcDaliActorPositionUsesAnchorPoint(void)
{
TestApplication application;
- tet_infoline( "Check default behaviour\n" );
+ tet_infoline("Check default behaviour\n");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- tet_infoline( "Check that the world position is in the center\n" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ tet_infoline("Check that the world position is in the center\n");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Set the position uses anchor point property to false\n" );
- actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
+ tet_infoline("Set the position uses anchor point property to false\n");
+ actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
application.SendNotification();
application.Render();
- tet_infoline( "Check that the world position has changed appropriately\n" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+ tet_infoline("Check that the world position has changed appropriately\n");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
END_TEST;
}
int utcDaliActorPositionUsesAnchorPointCheckScale(void)
{
TestApplication application;
- tet_infoline( "Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+ tet_infoline("Check that the scale is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::SCALE, 2.0f );
- actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::SCALE, 2.0f);
+ actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- tet_infoline( "Check the world position is the same as it would be without a scale\n" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+ tet_infoline("Check the world position is the same as it would be without a scale\n");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ tet_infoline("Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 100.0f, 100.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(100.0f, 100.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
END_TEST;
}
int utcDaliActorPositionUsesAnchorPointCheckRotation(void)
{
TestApplication application;
- tet_infoline( "Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+ tet_infoline("Check that the rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( 90.0f), Vector3::ZAXIS ) );
- actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::ZAXIS));
+ actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- tet_infoline( "Check the world position is the same as it would be without a rotation\n" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+ tet_infoline("Check the world position is the same as it would be without a rotation\n");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ tet_infoline("Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( -50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(-50.0f, 50.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 150.0f, 50.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(150.0f, 50.0f, 0.0f), TEST_LOCATION);
END_TEST;
}
int utcDaliActorPositionUsesAnchorPointCheckScaleAndRotation(void)
{
TestApplication application;
- tet_infoline( "Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+ tet_infoline("Check that the scale and rotation is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Degree( 90.0f), Vector3::ZAXIS ) );
- actor.SetProperty( Actor::Property::SCALE, 2.0f );
- actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Degree(90.0f), Vector3::ZAXIS));
+ actor.SetProperty(Actor::Property::SCALE, 2.0f);
+ actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- tet_infoline( "Check the world position is the same as it would be without a scale and rotation\n" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 50.0f, 50.0f, 0.0f ), TEST_LOCATION );
+ tet_infoline("Check the world position is the same as it would be without a scale and rotation\n");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(50.0f, 50.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ tet_infoline("Change the Anchor Point to TOP_LEFT and ensure the world position changes accordingly");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( -100.0f, 100.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(-100.0f, 100.0f, 0.0f), TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure the world position changes accordingly");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), Vector3( 200.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), Vector3(200.0f, 0.0f, 0.0f), TEST_LOCATION);
END_TEST;
}
int utcDaliActorPositionUsesAnchorPointOnlyInheritPosition(void)
{
TestApplication application;
- tet_infoline( "Check that if not inheriting scale and position, then the position is adjusted appropriately when setting the positionUsesAnchorPoint to false\n" );
+ tet_infoline("Check that if not inheriting scale and position, then the position is adjusted appropriately when setting the positionUsesAnchorPoint to false\n");
Actor parent = Actor::New();
- application.GetScene().Add( parent );
- Vector2 stageSize( application.GetScene().GetSize() );
+ application.GetScene().Add(parent);
+ Vector2 stageSize(application.GetScene().GetSize());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::INHERIT_SCALE, false );
- actor.SetProperty( Actor::Property::INHERIT_ORIENTATION, false );
- actor.SetProperty( Actor::Property::POSITION_USES_ANCHOR_POINT, false );
- parent.Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::INHERIT_SCALE, false);
+ actor.SetProperty(Actor::Property::INHERIT_ORIENTATION, false);
+ actor.SetProperty(Actor::Property::POSITION_USES_ANCHOR_POINT, false);
+ parent.Add(actor);
application.SendNotification();
application.Render();
- const Vector3 expectedWorldPosition( -stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f );
+ const Vector3 expectedWorldPosition(-stageSize.width * 0.5f + 50.0f, -stageSize.height * 0.5f + 50.0f, 0.0f);
- tet_infoline( "Check the world position is in the right place\n" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), expectedWorldPosition, TEST_LOCATION );
+ tet_infoline("Check the world position is in the right place\n");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), expectedWorldPosition, TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+ tet_infoline("Change the Anchor Point to TOP_LEFT and ensure world position hasn't changed");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), expectedWorldPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), expectedWorldPosition, TEST_LOCATION);
- tet_infoline( "Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT );
+ tet_infoline("Change the Anchor Point to BOTTOM_RIGHT and ensure world position hasn't changed");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), expectedWorldPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), expectedWorldPosition, TEST_LOCATION);
END_TEST;
}
int utcDaliActorVisibilityChangeSignalSelf(void)
{
TestApplication application;
- tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
+ tet_infoline("Check that the visibility change signal is called when the visibility changes for the actor itself");
Actor actor = Actor::New();
VisibilityChangedFunctorData data;
- DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
+ DevelActor::VisibilityChangedSignal(actor).Connect(&application, VisibilityChangedFunctor(data));
- actor.SetProperty( Actor::Property::VISIBLE, false );
+ actor.SetProperty(Actor::Property::VISIBLE, false);
- data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
+ data.Check(true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
- tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
+ tet_infoline("Ensure functor is not called if we attempt to change the visibility to what it already is at");
data.Reset();
- actor.SetProperty( Actor::Property::VISIBLE, false );
- data.Check( false /* not called */, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::VISIBLE, false);
+ data.Check(false /* not called */, TEST_LOCATION);
- tet_infoline( "Change the visibility using properties, ensure called" );
+ tet_infoline("Change the visibility using properties, ensure called");
data.Reset();
- actor.SetProperty( Actor::Property::VISIBLE, true );
- data.Check( true /* called */, actor, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::VISIBLE, true);
+ data.Check(true /* called */, actor, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
- tet_infoline( "Set the visibility to current using properties, ensure not called" );
+ tet_infoline("Set the visibility to current using properties, ensure not called");
data.Reset();
- actor.SetProperty( Actor::Property::VISIBLE, true );
- data.Check( false /* not called */, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::VISIBLE, true);
+ data.Check(false /* not called */, TEST_LOCATION);
END_TEST;
}
int utcDaliActorVisibilityChangeSignalChildren(void)
{
TestApplication application;
- tet_infoline( "Check that the visibility change signal is called for the children when the visibility changes for the parent" );
+ tet_infoline("Check that the visibility change signal is called for the children when the visibility changes for the parent");
Actor parent = Actor::New();
- Actor child = Actor::New();
- parent.Add( child );
+ Actor child = Actor::New();
+ parent.Add(child);
Actor grandChild = Actor::New();
- child.Add( grandChild );
+ child.Add(grandChild);
VisibilityChangedFunctorData parentData;
VisibilityChangedFunctorData childData;
VisibilityChangedFunctorData grandChildData;
- tet_infoline( "Only connect the child and grandchild, ensure they are called and not the parent" );
- DevelActor::VisibilityChangedSignal( child ).Connect( &application, VisibilityChangedFunctor( childData ) );
- DevelActor::VisibilityChangedSignal( grandChild ).Connect( &application, VisibilityChangedFunctor( grandChildData ) );
+ tet_infoline("Only connect the child and grandchild, ensure they are called and not the parent");
+ DevelActor::VisibilityChangedSignal(child).Connect(&application, VisibilityChangedFunctor(childData));
+ DevelActor::VisibilityChangedSignal(grandChild).Connect(&application, VisibilityChangedFunctor(grandChildData));
- parent.SetProperty( Actor::Property::VISIBLE, false );
- parentData.Check( false /* not called */, TEST_LOCATION );
- childData.Check( true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
- grandChildData.Check( true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
+ parent.SetProperty(Actor::Property::VISIBLE, false);
+ parentData.Check(false /* not called */, TEST_LOCATION);
+ childData.Check(true /* called */, child, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
+ grandChildData.Check(true /* called */, grandChild, false /* not visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
- tet_infoline( "Connect to the parent's signal as well and ensure all three are called" );
+ tet_infoline("Connect to the parent's signal as well and ensure all three are called");
parentData.Reset();
childData.Reset();
grandChildData.Reset();
- DevelActor::VisibilityChangedSignal( parent ).Connect( &application, VisibilityChangedFunctor( parentData ) );
+ DevelActor::VisibilityChangedSignal(parent).Connect(&application, VisibilityChangedFunctor(parentData));
- parent.SetProperty( Actor::Property::VISIBLE, true );
- parentData.Check( true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
- childData.Check( true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
- grandChildData.Check( true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION );
+ parent.SetProperty(Actor::Property::VISIBLE, true);
+ parentData.Check(true /* called */, parent, true /* visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
+ childData.Check(true /* called */, child, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
+ grandChildData.Check(true /* called */, grandChild, true /* visible */, DevelActor::VisibilityChange::PARENT, TEST_LOCATION);
- tet_infoline( "Ensure none of the functors are called if we attempt to change the visibility to what it already is at" );
+ tet_infoline("Ensure none of the functors are called if we attempt to change the visibility to what it already is at");
parentData.Reset();
childData.Reset();
grandChildData.Reset();
- parent.SetProperty( Actor::Property::VISIBLE, true );
- parentData.Check( false /* not called */, TEST_LOCATION );
- childData.Check( false /* not called */, TEST_LOCATION );
- grandChildData.Check( false /* not called */, TEST_LOCATION );
+ parent.SetProperty(Actor::Property::VISIBLE, true);
+ parentData.Check(false /* not called */, TEST_LOCATION);
+ childData.Check(false /* not called */, TEST_LOCATION);
+ grandChildData.Check(false /* not called */, TEST_LOCATION);
END_TEST;
}
int utcDaliActorVisibilityChangeSignalAfterAnimation(void)
{
TestApplication application;
- tet_infoline( "Check that the visibility change signal is emitted when the visibility changes when an animation starts" );
+ tet_infoline("Check that the visibility change signal is emitted when the visibility changes when an animation starts");
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
VisibilityChangedFunctorData data;
- DevelActor::VisibilityChangedSignal( actor ).Connect( &application, VisibilityChangedFunctor( data ) );
+ DevelActor::VisibilityChangedSignal(actor).Connect(&application, VisibilityChangedFunctor(data));
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( actor, Actor::Property::VISIBLE ), false );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::VISIBLE), false);
- data.Check( false, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ data.Check(false, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
- tet_infoline( "Play the animation and check the property value" );
+ tet_infoline("Play the animation and check the property value");
animation.Play();
- data.Check( true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
+ data.Check(true /* called */, actor, false /* not visible */, DevelActor::VisibilityChange::SELF, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
- tet_infoline( "Animation not currently finished, so the current visibility should still be true" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ tet_infoline("Animation not currently finished, so the current visibility should still be true");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
END_TEST;
}
-
int utcDaliActorVisibilityChangeSignalByName(void)
{
TestApplication application;
- tet_infoline( "Check that the visibility change signal is called when the visibility changes for the actor itself" );
+ tet_infoline("Check that the visibility change signal is called when the visibility changes for the actor itself");
Actor actor = Actor::New();
- bool signalCalled=false;
- actor.ConnectSignal( &application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled) );
- DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
- actor.SetProperty( Actor::Property::VISIBLE, false );
- DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+ bool signalCalled = false;
+ actor.ConnectSignal(&application, "visibilityChanged", VisibilityChangedVoidFunctor(signalCalled));
+ DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
+ DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
- tet_infoline( "Ensure functor is not called if we attempt to change the visibility to what it already is at" );
+ tet_infoline("Ensure functor is not called if we attempt to change the visibility to what it already is at");
signalCalled = false;
- actor.SetProperty( Actor::Property::VISIBLE, false );
- DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::VISIBLE, false);
+ DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
- tet_infoline( "Change the visibility using properties, ensure called" );
- actor.SetProperty( Actor::Property::VISIBLE, true );
- DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+ tet_infoline("Change the visibility using properties, ensure called");
+ actor.SetProperty(Actor::Property::VISIBLE, true);
+ DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
- tet_infoline( "Set the visibility to current using properties, ensure not called" );
+ tet_infoline("Set the visibility to current using properties, ensure not called");
signalCalled = false;
- actor.SetProperty( Actor::Property::VISIBLE, true );
- DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::VISIBLE, true);
+ DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
END_TEST;
}
-
-static void LayoutDirectionChanged( Actor actor, LayoutDirection::Type type )
+static void LayoutDirectionChanged(Actor actor, LayoutDirection::Type type)
{
gLayoutDirectionType = type;
}
int UtcDaliActorLayoutDirectionProperty(void)
{
TestApplication application;
- tet_infoline( "Check layout direction property" );
+ tet_infoline("Check layout direction property");
Actor actor0 = Actor::New();
- DALI_TEST_EQUALS( actor0.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- application.GetScene().Add( actor0 );
+ DALI_TEST_EQUALS(actor0.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ application.GetScene().Add(actor0);
application.SendNotification();
application.Render();
Actor actor1 = Actor::New();
- DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor1.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor2 = Actor::New();
- DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor2.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor3 = Actor::New();
- DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor3.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor4 = Actor::New();
- DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor4.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor5 = Actor::New();
- DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor5.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor6 = Actor::New();
- DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor6.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor7 = Actor::New();
- DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor7.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor8 = Actor::New();
- DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
Actor actor9 = Actor::New();
- DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
- actor1.Add( actor2 );
+ actor1.Add(actor2);
gLayoutDirectionType = LayoutDirection::LEFT_TO_RIGHT;
- actor2.LayoutDirectionChangedSignal().Connect( LayoutDirectionChanged );
+ actor2.LayoutDirectionChangedSignal().Connect(LayoutDirectionChanged);
- DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
- actor1.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
- DALI_TEST_EQUALS( actor1.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor1.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), true, TEST_LOCATION);
+ actor1.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
+ DALI_TEST_EQUALS(actor1.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), false, TEST_LOCATION);
- DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor1.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(gLayoutDirectionType, LayoutDirection::RIGHT_TO_LEFT, TEST_LOCATION);
- actor1.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
- actor0.Add( actor1 );
- DALI_TEST_EQUALS( actor1.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor2.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ actor1.SetProperty(Actor::Property::INHERIT_LAYOUT_DIRECTION, true);
+ actor0.Add(actor1);
+ DALI_TEST_EQUALS(actor1.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor2.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
- application.GetScene().Add( actor3 );
- actor3.Add( actor4 );
- actor4.Add( actor5 );
- actor5.Add( actor6 );
- actor5.Add( actor7 );
- actor7.Add( actor8 );
- actor8.Add( actor9 );
- actor3.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
- actor5.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
+ application.GetScene().Add(actor3);
+ actor3.Add(actor4);
+ actor4.Add(actor5);
+ actor5.Add(actor6);
+ actor5.Add(actor7);
+ actor7.Add(actor8);
+ actor8.Add(actor9);
+ actor3.SetProperty(Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT");
+ actor5.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT);
- DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), true, TEST_LOCATION );
- actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, false );
- DALI_TEST_EQUALS( actor8.GetProperty< bool >( Actor::Property::INHERIT_LAYOUT_DIRECTION ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor8.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), true, TEST_LOCATION);
+ actor8.SetProperty(Actor::Property::INHERIT_LAYOUT_DIRECTION, false);
+ DALI_TEST_EQUALS(actor8.GetProperty<bool>(Actor::Property::INHERIT_LAYOUT_DIRECTION), false, TEST_LOCATION);
- actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
+ actor7.SetProperty(Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT");
- DALI_TEST_EQUALS( actor3.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor4.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor5.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor6.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor3.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor4.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor5.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor6.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor7.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
- actor8.SetProperty( Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT" );
- DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ actor8.SetProperty(Actor::Property::LAYOUT_DIRECTION, "RIGHT_TO_LEFT");
+ DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
- actor7.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
- DALI_TEST_EQUALS( actor7.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
+ actor7.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT);
+ DALI_TEST_EQUALS(actor7.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::RIGHT_TO_LEFT), TEST_LOCATION);
- actor8.SetProperty( Actor::Property::INHERIT_LAYOUT_DIRECTION, true );
- DALI_TEST_EQUALS( actor8.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor9.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
+ actor8.SetProperty(Actor::Property::INHERIT_LAYOUT_DIRECTION, true);
+ DALI_TEST_EQUALS(actor8.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor9.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
END_TEST;
}
-
struct LayoutDirectionFunctor
{
LayoutDirectionFunctor(bool& signalCalled)
- : mSignalCalled( signalCalled )
+ : mSignalCalled(signalCalled)
{
}
LayoutDirectionFunctor(const LayoutDirectionFunctor& rhs)
- : mSignalCalled( rhs.mSignalCalled )
+ : mSignalCalled(rhs.mSignalCalled)
{
}
int UtcDaliActorLayoutDirectionSignal(void)
{
TestApplication application;
- tet_infoline( "Check changing layout direction property sends a signal" );
+ tet_infoline("Check changing layout direction property sends a signal");
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetProperty< int >( Actor::Property::LAYOUT_DIRECTION ), static_cast< int >( LayoutDirection::LEFT_TO_RIGHT ), TEST_LOCATION );
- application.GetScene().Add( actor );
- bool signalCalled = false;
+ DALI_TEST_EQUALS(actor.GetProperty<int>(Actor::Property::LAYOUT_DIRECTION), static_cast<int>(LayoutDirection::LEFT_TO_RIGHT), TEST_LOCATION);
+ application.GetScene().Add(actor);
+ bool signalCalled = false;
LayoutDirectionFunctor layoutDirectionFunctor(signalCalled);
- actor.ConnectSignal( &application, "layoutDirectionChanged", layoutDirectionFunctor );
- DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+ actor.ConnectSignal(&application, "layoutDirectionChanged", layoutDirectionFunctor);
+ DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
// Test that writing the same value doesn't send a signal
- actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT );
- DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::LEFT_TO_RIGHT);
+ DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
// Test that writing a different value sends the signal
signalCalled = false;
- actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
- DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
+ DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
signalCalled = false;
- actor.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
- DALI_TEST_EQUALS( signalCalled, false, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT);
+ DALI_TEST_EQUALS(signalCalled, false, TEST_LOCATION);
END_TEST;
}
struct ChildAddedSignalCheck
{
- ChildAddedSignalCheck( bool& signalReceived, Actor& childHandle )
- : mSignalReceived( signalReceived ),
- mChildHandle( childHandle )
+ ChildAddedSignalCheck(bool& signalReceived, Actor& childHandle)
+ : mSignalReceived(signalReceived),
+ mChildHandle(childHandle)
{
}
- void operator() ( Actor childHandle )
+ void operator()(Actor childHandle)
{
mSignalReceived = true;
- mChildHandle = childHandle;
+ mChildHandle = childHandle;
}
- void operator() ()
+ void operator()()
{
mSignalReceived = true;
- mChildHandle = Actor();
+ mChildHandle = Actor();
}
- bool& mSignalReceived;
+ bool& mSignalReceived;
Actor& mChildHandle;
};
int UtcDaliChildAddedSignalP1(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool signalReceived=false;
+ bool signalReceived = false;
Actor childActor;
- ChildAddedSignalCheck signal( signalReceived, childActor );
- DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ ChildAddedSignalCheck signal(signalReceived, childActor);
+ DevelActor::ChildAddedSignal(stage.GetRootLayer()).Connect(&application, signal);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
auto actorA = Actor::New();
- stage.Add( actorA );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+ stage.Add(actorA);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor, actorA, TEST_LOCATION);
signalReceived = false;
auto actorB = Actor::New();
- stage.Add( actorB );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
+ stage.Add(actorB);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor, actorB, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliChildAddedSignalP2(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool signalReceived=false;
+ bool signalReceived = false;
Actor childActor;
- ChildAddedSignalCheck signal( signalReceived, childActor );
- tet_infoline( "Connect to childAdded signal by name" );
+ ChildAddedSignalCheck signal(signalReceived, childActor);
+ tet_infoline("Connect to childAdded signal by name");
- stage.GetRootLayer().ConnectSignal( &application, "childAdded", signal );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ stage.GetRootLayer().ConnectSignal(&application, "childAdded", signal);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
auto actorA = Actor::New();
- stage.Add( actorA );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ stage.Add(actorA);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
// Can't test which actor was added; signal signature is void() when connecting via name.
signalReceived = false;
auto actorB = Actor::New();
- stage.Add( actorB );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ stage.Add(actorB);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliChildAddedSignalN(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool signalReceived=false;
+ bool signalReceived = false;
Actor childActor;
- ChildAddedSignalCheck signal( signalReceived, childActor );
- DevelActor::ChildAddedSignal( stage.GetRootLayer() ).Connect( &application, signal );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ ChildAddedSignalCheck signal(signalReceived, childActor);
+ DevelActor::ChildAddedSignal(stage.GetRootLayer()).Connect(&application, signal);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
auto actorA = Actor::New();
- stage.Add( actorA );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
+ stage.Add(actorA);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor, actorA, TEST_LOCATION);
signalReceived = false;
auto actorB = Actor::New();
- actorA.Add( actorB );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ actorA.Add(actorB);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
END_TEST;
}
-
struct ChildRemovedSignalCheck
{
- ChildRemovedSignalCheck( bool& signalReceived, Actor& childHandle )
- : mSignalReceived( signalReceived ),
- mChildHandle( childHandle )
+ ChildRemovedSignalCheck(bool& signalReceived, Actor& childHandle)
+ : mSignalReceived(signalReceived),
+ mChildHandle(childHandle)
{
}
- void operator() ( Actor childHandle )
+ void operator()(Actor childHandle)
{
mSignalReceived = true;
- mChildHandle = childHandle;
+ mChildHandle = childHandle;
}
- void operator() ()
+ void operator()()
{
mSignalReceived = true;
}
- bool& mSignalReceived;
+ bool& mSignalReceived;
Actor& mChildHandle;
};
int UtcDaliChildRemovedSignalP1(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool signalReceived=false;
+ bool signalReceived = false;
Actor childActor;
- ChildRemovedSignalCheck signal( signalReceived, childActor );
- DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ ChildRemovedSignalCheck signal(signalReceived, childActor);
+ DevelActor::ChildRemovedSignal(stage.GetRootLayer()).Connect(&application, signal);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
auto actorA = Actor::New();
- stage.Add( actorA );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
- DALI_TEST_CHECK( !childActor );
+ stage.Add(actorA);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
+ DALI_TEST_CHECK(!childActor);
- stage.Remove( actorA );
- DALI_TEST_EQUALS( childActor, actorA, TEST_LOCATION );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ stage.Remove(actorA);
+ DALI_TEST_EQUALS(childActor, actorA, TEST_LOCATION);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
signalReceived = false;
- auto actorB = Actor::New();
- stage.Add( actorB );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ auto actorB = Actor::New();
+ stage.Add(actorB);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
- stage.Remove( actorB );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor, actorB, TEST_LOCATION );
+ stage.Remove(actorB);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor, actorB, TEST_LOCATION);
END_TEST;
}
int UtcDaliChildRemovedSignalP2(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool signalReceived=false;
+ bool signalReceived = false;
Actor childActor;
- ChildAddedSignalCheck signal( signalReceived, childActor );
- tet_infoline( "Connect to childRemoved signal by name" );
+ ChildAddedSignalCheck signal(signalReceived, childActor);
+ tet_infoline("Connect to childRemoved signal by name");
- stage.GetRootLayer().ConnectSignal( &application, "childRemoved", signal );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ stage.GetRootLayer().ConnectSignal(&application, "childRemoved", signal);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
auto actorA = Actor::New();
- stage.Add( actorA );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ stage.Add(actorA);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
- stage.Remove( actorA );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ stage.Remove(actorA);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
signalReceived = false;
- auto actorB = Actor::New();
- stage.Add( actorB );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ auto actorB = Actor::New();
+ stage.Add(actorB);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
- stage.Remove( actorB );
- DALI_TEST_EQUALS( signalReceived, true, TEST_LOCATION );
+ stage.Remove(actorB);
+ DALI_TEST_EQUALS(signalReceived, true, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliChildRemovedSignalN(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool signalReceived=false;
+ bool signalReceived = false;
Actor childActor;
- ChildRemovedSignalCheck signal( signalReceived, childActor );
- DevelActor::ChildRemovedSignal( stage.GetRootLayer() ).Connect( &application, signal );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ ChildRemovedSignalCheck signal(signalReceived, childActor);
+ DevelActor::ChildRemovedSignal(stage.GetRootLayer()).Connect(&application, signal);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
auto actorA = Actor::New();
- stage.Add( actorA );
+ stage.Add(actorA);
auto actorB = Actor::New();
- actorA.Add( actorB );
+ actorA.Add(actorB);
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
- DALI_TEST_CHECK( ! childActor );
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
+ DALI_TEST_CHECK(!childActor);
- actorA.Remove( actorB );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ actorA.Remove(actorB);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliChildMovedSignalP(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- bool addedASignalReceived = false;
- bool removedASignalReceived = false;
- bool addedBSignalReceived = false;
- bool removedBSignalReceived = false;
+ bool addedASignalReceived = false;
+ bool removedASignalReceived = false;
+ bool addedBSignalReceived = false;
+ bool removedBSignalReceived = false;
Actor childActor;
auto actorA = Actor::New();
auto actorB = Actor::New();
- stage.Add( actorA );
- stage.Add( actorB );
+ stage.Add(actorA);
+ stage.Add(actorB);
- ChildAddedSignalCheck addedSignalA( addedASignalReceived, childActor );
- ChildRemovedSignalCheck removedSignalA( removedASignalReceived, childActor );
- ChildAddedSignalCheck addedSignalB( addedBSignalReceived, childActor );
- ChildRemovedSignalCheck removedSignalB( removedBSignalReceived, childActor );
+ ChildAddedSignalCheck addedSignalA(addedASignalReceived, childActor);
+ ChildRemovedSignalCheck removedSignalA(removedASignalReceived, childActor);
+ ChildAddedSignalCheck addedSignalB(addedBSignalReceived, childActor);
+ ChildRemovedSignalCheck removedSignalB(removedBSignalReceived, childActor);
- DevelActor::ChildAddedSignal( actorA ).Connect( &application, addedSignalA );
- DevelActor::ChildRemovedSignal( actorA ).Connect( &application, removedSignalA );
- DevelActor::ChildAddedSignal( actorB ).Connect( &application, addedSignalB );
- DevelActor::ChildRemovedSignal( actorB ).Connect( &application, removedSignalB );
+ DevelActor::ChildAddedSignal(actorA).Connect(&application, addedSignalA);
+ DevelActor::ChildRemovedSignal(actorA).Connect(&application, removedSignalA);
+ DevelActor::ChildAddedSignal(actorB).Connect(&application, addedSignalB);
+ DevelActor::ChildRemovedSignal(actorB).Connect(&application, removedSignalB);
- DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(addedASignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedASignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(addedBSignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedBSignalReceived, false, TEST_LOCATION);
// Create a child of A
auto child = Actor::New();
- actorA.Add( child );
+ actorA.Add(child);
- DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor, child, TEST_LOCATION );
+ DALI_TEST_EQUALS(addedASignalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedASignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(addedBSignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedBSignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor, child, TEST_LOCATION);
// Move child to B:
addedASignalReceived = false;
removedASignalReceived = false;
removedBSignalReceived = false;
- actorB.Add( child ); // Expect this child to be re-parented
- DALI_TEST_EQUALS( addedASignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( removedASignalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( addedBSignalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( removedBSignalReceived, false, TEST_LOCATION );
+ actorB.Add(child); // Expect this child to be re-parented
+ DALI_TEST_EQUALS(addedASignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedASignalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(addedBSignalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedBSignalReceived, false, TEST_LOCATION);
// Move child back to A:
addedASignalReceived = false;
removedASignalReceived = false;
removedBSignalReceived = false;
- actorA.Add( child ); // Expect this child to be re-parented
- DALI_TEST_EQUALS( addedASignalReceived, true, TEST_LOCATION );
- DALI_TEST_EQUALS( removedASignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( addedBSignalReceived, false, TEST_LOCATION );
- DALI_TEST_EQUALS( removedBSignalReceived, true, TEST_LOCATION );
-
+ actorA.Add(child); // Expect this child to be re-parented
+ DALI_TEST_EQUALS(addedASignalReceived, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedASignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(addedBSignalReceived, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(removedBSignalReceived, true, TEST_LOCATION);
END_TEST;
}
int utcDaliActorCulled(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- tet_infoline( "Check that the actor is culled if the actor is out of the screen" );
+ tet_infoline("Check that the actor is culled if the actor is out of the screen");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- actor.AddRenderer( renderer );
+ actor.AddRenderer(renderer);
- stage.Add( actor );
+ stage.Add(actor);
application.SendNotification();
- application.Render( 0 );
+ application.Render(0);
- DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::CULLED ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::CULLED), false, TEST_LOCATION);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::CULLED, LessThanCondition( 0.5f ) );
- notification.SetNotifyMode( PropertyNotification::NOTIFY_ON_CHANGED );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::CULLED, LessThanCondition(0.5f));
+ notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
// Connect NotifySignal
- bool propertyNotificationSignal( false );
- PropertyNotification source;
- CulledPropertyNotificationFunctor f( propertyNotificationSignal, source );
- notification.NotifySignal().Connect( &application, f ) ;
+ bool propertyNotificationSignal(false);
+ PropertyNotification source;
+ CulledPropertyNotificationFunctor f(propertyNotificationSignal, source);
+ notification.NotifySignal().Connect(&application, f);
- actor.SetProperty( Actor::Property::POSITION, Vector2( 1000.0f, 1000.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(1000.0f, 1000.0f));
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::CULLED ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::CULLED), true, TEST_LOCATION);
- DALI_TEST_EQUALS( propertyNotificationSignal, true, TEST_LOCATION );
- DALI_TEST_EQUALS( source.GetTargetProperty(), static_cast< int >( Actor::Property::CULLED ), TEST_LOCATION );
- DALI_TEST_EQUALS( source.GetTarget().GetProperty< bool >( source.GetTargetProperty() ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(propertyNotificationSignal, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.GetTargetProperty(), static_cast<int>(Actor::Property::CULLED), TEST_LOCATION);
+ DALI_TEST_EQUALS(source.GetTarget().GetProperty<bool>(source.GetTargetProperty()), true, TEST_LOCATION);
END_TEST;
}
int utcDaliEnsureRenderWhenRemovingLastRenderableActor(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- tet_infoline( "Ensure we clear the screen when the last actor is removed" );
+ tet_infoline("Ensure we clear the screen when the last actor is removed");
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- stage.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ stage.Add(actor);
application.SendNotification();
application.Render();
- auto& glAbstraction = application.GetGlAbstraction();
+ auto& glAbstraction = application.GetGlAbstraction();
const auto clearCountBefore = glAbstraction.GetClearCountCalled();
actor.Unparent();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
END_TEST;
}
int utcDaliEnsureRenderWhenMakingLastActorInvisible(void)
{
TestApplication application;
- auto stage = application.GetScene();
+ auto stage = application.GetScene();
- tet_infoline( "Ensure we clear the screen when the last actor is made invisible" );
+ tet_infoline("Ensure we clear the screen when the last actor is made invisible");
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- stage.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ stage.Add(actor);
application.SendNotification();
application.Render();
- auto& glAbstraction = application.GetGlAbstraction();
+ auto& glAbstraction = application.GetGlAbstraction();
const auto clearCountBefore = glAbstraction.GetClearCountCalled();
- actor.SetProperty( Actor::Property::VISIBLE, false );
+ actor.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
END_TEST;
}
int utcDaliActorGetSizeAfterAnimation(void)
{
TestApplication application;
- tet_infoline( "Check the actor size before / after an animation is finished" );
+ tet_infoline("Check the actor size before / after an animation is finished");
- Vector3 actorSize( 100.0f, 100.0f, 0.0f );
+ Vector3 actorSize(100.0f, 100.0f, 0.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, actorSize );
- actor.SetResizePolicy( ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
+ actor.SetResizePolicy(ResizePolicy::FIXED, Dimension::ALL_DIMENSIONS);
+ application.GetScene().Add(actor);
// Size should be updated without rendering.
- Vector3 size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ Vector3 size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
application.SendNotification();
application.Render();
// Size and current size should be updated.
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( actorSize.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorSize.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorSize.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
-
- Vector3 currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( actorSize.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorSize.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorSize.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
+
+ Vector3 currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorSize.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
// Set size again
- actorSize = Vector3( 200.0f, 200.0f, 0.0f );
- actor.SetProperty( Actor::Property::SIZE, actorSize );
+ actorSize = Vector3(200.0f, 200.0f, 0.0f);
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- Vector3 targetValue( 10.0f, 20.0f, 0.0f );
+ Vector3 targetValue(10.0f, 20.0f, 0.0f);
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetValue );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetValue);
animation.Play();
// Size should be updated without rendering.
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
targetValue.width = 50.0f;
animation.Clear();
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetValue.width );
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_WIDTH), targetValue.width);
animation.Play();
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
targetValue.height = 70.0f;
animation.Clear();
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetValue.height );
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_HEIGHT), targetValue.height);
animation.Play();
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- Vector3 offset( 10.0f, 20.0f, 0.0f );
+ Vector3 offset(10.0f, 20.0f, 0.0f);
animation.Clear();
- animation.AnimateBy( Property( actor, Actor::Property::SIZE ), offset );
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE), offset);
animation.Play();
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
targetValue += offset;
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
offset.width = 20.0f;
animation.Clear();
- animation.AnimateBy( Property( actor, Actor::Property::SIZE_WIDTH ), offset.width );
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE_WIDTH), offset.width);
animation.Play();
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
targetValue.width += offset.width;
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
offset.height = 10.0f;
animation.Clear();
- animation.AnimateBy( Property( actor, Actor::Property::SIZE_HEIGHT ), offset.height );
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE_HEIGHT), offset.height);
animation.Play();
application.SendNotification();
- application.Render( 1100 ); // After the animation
+ application.Render(1100); // After the animation
targetValue.height += offset.height;
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.width, actor.GetCurrentProperty< float >( Actor::Property::SIZE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.height, actor.GetCurrentProperty< float >( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
- DALI_TEST_EQUALS( targetValue.depth, actor.GetCurrentProperty< float >( Actor::Property::SIZE_DEPTH ), TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.width, actor.GetCurrentProperty<float>(Actor::Property::SIZE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.height, actor.GetCurrentProperty<float>(Actor::Property::SIZE_HEIGHT), TEST_LOCATION);
+ DALI_TEST_EQUALS(targetValue.depth, actor.GetCurrentProperty<float>(Actor::Property::SIZE_DEPTH), TEST_LOCATION);
// Set size again
- actorSize = Vector3( 300.0f, 300.0f, 0.0f );
+ actorSize = Vector3(300.0f, 300.0f, 0.0f);
- actor.SetProperty( Actor::Property::SIZE, actorSize );
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, targetValue, Math::MACHINE_EPSILON_0, TEST_LOCATION);
application.SendNotification();
application.Render();
- size = actor.GetProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ size = actor.GetProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(size, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
- currentSize = actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >();
- DALI_TEST_EQUALS( currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION );
+ currentSize = actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>();
+ DALI_TEST_EQUALS(currentSize, actorSize, Math::MACHINE_EPSILON_0, TEST_LOCATION);
END_TEST;
}
tet_infoline("Check the damaged area");
- const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
std::vector<Rect<int>> damagedRects;
- Rect<int> clippingRect;
+ Rect<int> clippingRect;
application.SendNotification();
application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
tet_infoline("Check uniform update");
- const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
std::vector<Rect<int>> damagedRects;
- Rect<int> clippingRect;
+ Rect<int> clippingRect;
application.SendNotification();
application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
true,
true);
- tet_infoline( "Set/Update property with partial update" );
+ tet_infoline("Set/Update property with partial update");
const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
std::vector<Rect<int>> damagedRects;
- Rect<int> clippingRect;
+ Rect<int> clippingRect;
application.SendNotification();
application.PreRenderWithPartialUpdate(TestApplication::RENDER_FRAME_INTERVAL, nullptr, damagedRects);
application.RenderWithPartialUpdate(damagedRects, clippingRect);
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
- Actor actor = CreateRenderableActor(image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE);
+ Actor actor = CreateRenderableActor(image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE);
actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
actor.SetProperty(Actor::Property::POSITION, Vector3(16.0f, 16.0f, 0.0f));
actor.SetProperty(Actor::Property::SIZE, Vector3(16.0f, 16.0f, 0.0f));
DALI_TEST_EQUALS(clippingRect.width, glScissorParams.width, TEST_LOCATION);
DALI_TEST_EQUALS(clippingRect.height, glScissorParams.height, TEST_LOCATION);
- Property::Index shadowColorPropertyIndex = actor.GetPropertyIndex( SHADER_SHADOW_COLOR_PROPERTY_NAME );
+ Property::Index shadowColorPropertyIndex = actor.GetPropertyIndex(SHADER_SHADOW_COLOR_PROPERTY_NAME);
actor.SetProperty(shadowColorPropertyIndex, Vector4(1.0f, 1.0f, 0.0f, 1.0f));
damagedRects.clear();
tet_infoline("Check the damaged rects with partial update and two actors");
- const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
Actor actor = CreateRenderableActor();
actor.SetProperty(Actor::Property::POSITION, Vector3(100.0f, 100.0f, 0.0f));
true,
true);
- tet_infoline( "Check the damaged rect with partial update and actor size hint" );
+ tet_infoline("Check the damaged rect with partial update and actor size hint");
- const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
Actor actor = CreateRenderableActor();
actor.SetProperty(Actor::Property::POSITION, Vector3(75.0f, 150.0f, 0.0f));
}
catch(...)
{
- tet_result(TET_FAIL);
+ tet_result(TET_FAIL);
}
END_TEST;
}
int UtcDaliActorLowerBelowNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Actor arg1;
int UtcDaliActorRaiseAboveNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Actor arg1;
int UtcDaliActorRaiseToTopNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.RaiseToTop();
int UtcDaliActorAddRendererNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Renderer arg1;
int UtcDaliActorTouchedSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.TouchedSignal();
int UtcDaliActorTranslateByNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Vector3 arg1;
int UtcDaliActorFindChildByIdNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
unsigned int arg1 = 0u;
int UtcDaliActorGetRendererAtNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
unsigned int arg1 = 0u;
int UtcDaliActorHoveredSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.HoveredSignal();
int UtcDaliActorLowerToBottomNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.LowerToBottom();
int UtcDaliActorOnSceneSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.OnSceneSignal();
int UtcDaliActorOffSceneSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.OffSceneSignal();
int UtcDaliActorRemoveRendererNegative01(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
unsigned int arg1 = 0u;
int UtcDaliActorRemoveRendererNegative02(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Renderer arg1;
int UtcDaliActorFindChildByNameNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
std::string arg1;
int UtcDaliActorSetResizePolicyNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::ResizePolicy::Type arg1 = ResizePolicy::USE_NATURAL_SIZE;
- Dali::Dimension::Type arg2 = Dimension::ALL_DIMENSIONS;
- instance.SetResizePolicy(arg1,arg2);
+ Dali::Dimension::Type arg2 = Dimension::ALL_DIMENSIONS;
+ instance.SetResizePolicy(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliActorOnRelayoutSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.OnRelayoutSignal();
int UtcDaliActorWheelEventSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.WheelEventSignal();
int UtcDaliActorGetHeightForWidthNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
float arg1 = 0.0f;
int UtcDaliActorGetWidthForHeightNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
float arg1 = 0.0f;
int UtcDaliActorLayoutDirectionChangedSignalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.LayoutDirectionChangedSignal();
int UtcDaliActorAddNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Actor arg1;
int UtcDaliActorLowerNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.Lower();
int UtcDaliActorRaiseNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.Raise();
int UtcDaliActorRemoveNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Actor arg1;
int UtcDaliActorScaleByNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Vector3 arg1;
int UtcDaliActorGetLayerNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.GetLayer();
int UtcDaliActorRotateByNegative01(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Quaternion arg1;
int UtcDaliActorRotateByNegative02(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
- Dali::Radian arg1;
+ Dali::Radian arg1;
Dali::Vector3 arg2;
- instance.RotateBy(arg1,arg2);
+ instance.RotateBy(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliActorUnparentNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.Unparent();
int UtcDaliActorGetChildAtNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
unsigned int arg1 = 0u;
int UtcDaliActorGetChildCountNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.GetChildCount();
int UtcDaliActorGetTargetSizeNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.GetTargetSize();
int UtcDaliActorScreenToLocalNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
float arg1 = 0.0f;
float arg2 = 0.0f;
float arg3 = 0.0f;
float arg4 = 0.0f;
- instance.ScreenToLocal(arg1,arg2,arg3,arg4);
+ instance.ScreenToLocal(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliActorGetNaturalSizeNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.GetNaturalSize();
int UtcDaliActorGetRelayoutSizeNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Dimension::Type arg1 = Dimension::HEIGHT;
int UtcDaliActorGetResizePolicyNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
Dali::Dimension::Type arg1 = Dimension::ALL_DIMENSIONS;
int UtcDaliActorGetRendererCountNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.GetRendererCount();
int UtcDaliActorGetParentNegative(void)
{
TestApplication application;
- Dali::Actor instance;
+ Dali::Actor instance;
try
{
instance.GetParent();
#include <dali-test-suite-utils.h>
#include <dali/devel-api/common/addon-binder.h>
+
#include "dali-test-suite-utils/test-addon-manager.h"
struct DummyAddOn : public Dali::AddOn::AddOnBinder
{
- DummyAddOn() : Dali::AddOn::AddOnBinder( "SampleAddOn" )
- {}
+ DummyAddOn()
+ : Dali::AddOn::AddOnBinder("SampleAddOn")
+ {
+ }
- ~DummyAddOn() = default;
+ ~DummyAddOn() override = default;
- ADDON_BIND_FUNCTION( DoSum, int(int, int) );
+ ADDON_BIND_FUNCTION(DoSum, int(int, int));
- ADDON_BIND_FUNCTION( StringLen, int() );
+ ADDON_BIND_FUNCTION(StringLen, int());
};
int UtcDaliAddOnBinderP(void)
DummyAddOn addon;
// Test whether library handle is non-null
- DALI_TEST_EQUALS( addon.GetHandle(), (void*)1, TEST_LOCATION );
+ DALI_TEST_EQUALS(addon.GetHandle(), (void*)1, TEST_LOCATION);
// Test whether addon is valid
auto isValid = addon.IsValid();
- DALI_TEST_EQUALS( isValid, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(isValid, true, TEST_LOCATION);
// Test AddOnInfo
const auto& info = addon.GetAddOnInfo();
- DALI_TEST_EQUALS( info.name, "SampleAddOn", TEST_LOCATION );
+ DALI_TEST_EQUALS(info.name, "SampleAddOn", TEST_LOCATION);
delete addOnManager;
// Not supported
using VoidPtr = void*;
- DALI_TEST_EQUALS( VoidPtr(Dali::Integration::AddOnManager::Get()), VoidPtr(nullptr), TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidPtr(Dali::Integration::AddOnManager::Get()), VoidPtr(nullptr), TEST_LOCATION);
DummyAddOn addon{};
// Test whether library handle is non-null
- DALI_TEST_EQUALS( addon.GetHandle(), (void*)0, TEST_LOCATION );
+ DALI_TEST_EQUALS(addon.GetHandle(), (void*)0, TEST_LOCATION);
// Test whether addon is valid
auto isValid = addon.IsValid();
- DALI_TEST_EQUALS( isValid, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(isValid, false, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
-float customAlphaFunction( float progress )
+float customAlphaFunction(float progress)
{
return progress;
}
int UtcDaliAlphaFunctionDefaultConstructorP(void)
{
TestApplication application;
- AlphaFunction alpha;
+ AlphaFunction alpha;
//Should return the default alpha function
- DALI_TEST_EQUALS( alpha.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
//Check the mode is BUILTIN_FUNCTION
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
END_TEST;
}
TestApplication application;
//Construct the alpha function with a built-in function
- AlphaFunction alpha( AlphaFunction::EASE_IN_OUT);
+ AlphaFunction alpha(AlphaFunction::EASE_IN_OUT);
//Check if the built-in alpha function is EASE_IN_OUT
- DALI_TEST_EQUALS( alpha.GetBuiltinFunction(), AlphaFunction::EASE_IN_OUT, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetBuiltinFunction(), AlphaFunction::EASE_IN_OUT, TEST_LOCATION);
//Check the mode is BUILTIN_FUNCTION
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
END_TEST;
}
TestApplication application;
//Construct the alpha function with a function pointer
- AlphaFunction alpha( &customAlphaFunction );
+ AlphaFunction alpha(&customAlphaFunction);
//Check that the custom function points to the custom alpha function
- DALI_TEST_EQUALS( alpha.GetCustomFunction(), &customAlphaFunction, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetCustomFunction(), &customAlphaFunction, TEST_LOCATION);
//Check the mode is CUSTOM_FUNCTION
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::CUSTOM_FUNCTION, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::CUSTOM_FUNCTION, TEST_LOCATION);
END_TEST;
}
TestApplication application;
//Construct the alpha function with two control points
- Vector2 controlPoint0 = Vector2(0.0f,1.0f);
- Vector2 controlPoint1 = Vector2(1.0f,0.0f);
- AlphaFunction alpha(controlPoint0,controlPoint1);
+ Vector2 controlPoint0 = Vector2(0.0f, 1.0f);
+ Vector2 controlPoint1 = Vector2(1.0f, 0.0f);
+ AlphaFunction alpha(controlPoint0, controlPoint1);
//Check if the control points have the correct value
Vector4 controlPoints = alpha.GetBezierControlPoints();
- DALI_TEST_EQUALS( Vector2(controlPoints.x,controlPoints.y), controlPoint0, TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(controlPoints.z,controlPoints.w), controlPoint1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(controlPoints.x, controlPoints.y), controlPoint0, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(controlPoints.z, controlPoints.w), controlPoint1, TEST_LOCATION);
//Check the mode is BEZIER
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
END_TEST;
}
TestApplication application;
//Construct the alpha function with two control points
- Vector2 controlPoint0 = Vector2(-10.0f,1.0f);
- Vector2 controlPoint1 = Vector2(10.0f,0.0f);
- AlphaFunction alpha(controlPoint0,controlPoint1);
+ Vector2 controlPoint0 = Vector2(-10.0f, 1.0f);
+ Vector2 controlPoint1 = Vector2(10.0f, 0.0f);
+ AlphaFunction alpha(controlPoint0, controlPoint1);
//x components of the control points should have been clamped to [0,1] to ensure the curve is monotonic
Vector4 controlPoints = alpha.GetBezierControlPoints();
- DALI_TEST_EQUALS( Vector2(controlPoints.x,controlPoints.y), Vector2(0.0f,1.0f), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(controlPoints.z,controlPoints.w), Vector2(1.0f,0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(controlPoints.x, controlPoints.y), Vector2(0.0f, 1.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(controlPoints.z, controlPoints.w), Vector2(1.0f, 0.0f), TEST_LOCATION);
//Check the mode is BEZIER
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
END_TEST;
}
int UtcDaliAlphaFunctionGetBuiltinFunctionP(void)
{
TestApplication application;
- AlphaFunction alpha( AlphaFunction::EASE_IN);
+ AlphaFunction alpha(AlphaFunction::EASE_IN);
//Check if the builtin alpha function is EASE_IN
- DALI_TEST_EQUALS( alpha.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetBuiltinFunction(), AlphaFunction::EASE_IN, TEST_LOCATION);
//Check the mode is BUILTIN_FUNCTION
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliAlphaFunctionGetCustomFunctionP(void)
{
TestApplication application;
- AlphaFunction alpha( &customAlphaFunction );
+ AlphaFunction alpha(&customAlphaFunction);
//Check that the custom function points to the custom alpha function
- DALI_TEST_EQUALS( alpha.GetCustomFunction(), &customAlphaFunction, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetCustomFunction(), &customAlphaFunction, TEST_LOCATION);
//Check the mode is CUSTOM_FUNCTION
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::CUSTOM_FUNCTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::CUSTOM_FUNCTION, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Vector2 controlPoint0 = Vector2(0.0f,1.0f);
- Vector2 controlPoint1 = Vector2(1.0f,0.0f);
- AlphaFunction alpha( controlPoint0,controlPoint1 );
+ Vector2 controlPoint0 = Vector2(0.0f, 1.0f);
+ Vector2 controlPoint1 = Vector2(1.0f, 0.0f);
+ AlphaFunction alpha(controlPoint0, controlPoint1);
//Check if the control points have the correct value
Vector4 controlPoints = alpha.GetBezierControlPoints();
- DALI_TEST_EQUALS( Vector2(controlPoints.x,controlPoints.y), controlPoint0, TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(controlPoints.z,controlPoints.w), controlPoint1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(controlPoints.x, controlPoints.y), controlPoint0, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(controlPoints.z, controlPoints.w), controlPoint1, TEST_LOCATION);
//Check the mode is BEZIER
- DALI_TEST_EQUALS( alpha.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
+ DALI_TEST_EQUALS(alpha.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
END_TEST;
}
TestApplication application;
//Create alpha function using a built-in function
- AlphaFunction alphaBuiltin( AlphaFunction::EASE_IN);
+ AlphaFunction alphaBuiltin(AlphaFunction::EASE_IN);
//Check the mode is BUILTIN_FUNCTION
- DALI_TEST_EQUALS( alphaBuiltin.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(alphaBuiltin.GetMode(), AlphaFunction::BUILTIN_FUNCTION, TEST_LOCATION);
//Create alpha function with pointer to function
- AlphaFunction alphaCustom( &customAlphaFunction );
+ AlphaFunction alphaCustom(&customAlphaFunction);
//Check the mode is CUSTOM_FUNCTION
- DALI_TEST_EQUALS( alphaCustom.GetMode(), AlphaFunction::CUSTOM_FUNCTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(alphaCustom.GetMode(), AlphaFunction::CUSTOM_FUNCTION, TEST_LOCATION);
//Create alpha function with control points
- Vector2 controlPoint0 = Vector2(0.0f,1.0f);
- Vector2 controlPoint1 = Vector2(1.0f,0.0f);
- AlphaFunction alphaBezier( controlPoint0,controlPoint1 );
+ Vector2 controlPoint0 = Vector2(0.0f, 1.0f);
+ Vector2 controlPoint1 = Vector2(1.0f, 0.0f);
+ AlphaFunction alphaBezier(controlPoint0, controlPoint1);
//Check the mode is BEZIER
- DALI_TEST_EQUALS( alphaBezier.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
+ DALI_TEST_EQUALS(alphaBezier.GetMode(), AlphaFunction::BEZIER, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(0.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(0.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(1.0f);
+ float targetValue(1.0f);
- Vector2 controlPoint0 = Vector2(0.25f,0.5f);
- Vector2 controlPoint1 = Vector2(0.75f,0.5f);
- animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction(controlPoint0,controlPoint1));
+ Vector2 controlPoint0 = Vector2(0.25f, 0.5f);
+ Vector2 controlPoint1 = Vector2(0.75f, 0.5f);
+ animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction(controlPoint0, controlPoint1));
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
application.SendNotification();
float epsilon(0.01f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 0.271964f, epsilon, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 0.271964f, epsilon, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*40% progress*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*40% progress*/);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 0.432387f, epsilon, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 0.432387f, epsilon, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*60% progress*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*60% progress*/);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 0.567613f, epsilon, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 0.567613f, epsilon, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*80% progress*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*80% progress*/);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 0.728037f, epsilon, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 0.728037f, epsilon, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
-
*
*/
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
void utc_dali_angle_axis_startup(void)
{
test_return_value = TET_PASS;
}
-
-
int UtcDaliAngleAxisNew01(void)
{
TestApplication application;
END_TEST;
}
-
-
int UtcDaliAngleAxisNew02(void)
{
TestApplication application;
- Degree d(75.0f);
+ Degree d(75.0f);
AngleAxis a(d, Vector3::XAXIS);
DALI_TEST_EQUALS(a.angle, Radian(d), 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliAngleAxisNew03(void)
{
TestApplication application;
- Radian r(Math::PI_2);
+ Radian r(Math::PI_2);
AngleAxis a(r, Vector3::ZAXIS);
// AngleAxis stores its angle as a degree, so should only do degree comparison.
{
TestApplication application;
- Radian r(Math::PI_2);
+ Radian r(Math::PI_2);
AngleAxis a(r, Vector3::ZAXIS);
AngleAxis b = a;
{
TestApplication application;
- Radian r( Math::PI_2 );
- AngleAxis a( r, Vector3::ZAXIS );
- AngleAxis b( a );
+ Radian r(Math::PI_2);
+ AngleAxis a(r, Vector3::ZAXIS);
+ AngleAxis b(a);
// AngleAxis stores its angle as a degree, so should only do degree comparison.
- DALI_TEST_EQUALS( b.angle, Radian( Math::PI_2 ), 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(b.angle, Radian(Math::PI_2), 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Radian r( Math::PI_2 );
- AngleAxis a( r, Vector3::ZAXIS );
- AngleAxis b = std::move( a );
+ Radian r(Math::PI_2);
+ AngleAxis a(r, Vector3::ZAXIS);
+ AngleAxis b = std::move(a);
// AngleAxis stores its angle as a degree, so should only do degree comparison.
- DALI_TEST_EQUALS( b.angle, Radian( Math::PI_2 ), 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(b.angle, Radian(Math::PI_2), 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Radian r( Math::PI_2 );
- AngleAxis a( r, Vector3::ZAXIS );
+ Radian r(Math::PI_2);
+ AngleAxis a(r, Vector3::ZAXIS);
AngleAxis b;
b = a;
// AngleAxis stores its angle as a degree, so should only do degree comparison.
- DALI_TEST_EQUALS( b.angle, Radian( Math::PI_2 ), 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(b.angle, Radian(Math::PI_2), 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Radian r( Math::PI_2 );
- AngleAxis a( r, Vector3::ZAXIS );
+ Radian r(Math::PI_2);
+ AngleAxis a(r, Vector3::ZAXIS);
AngleAxis b;
- b = std::move( a );
+ b = std::move(a);
// AngleAxis stores its angle as a degree, so should only do degree comparison.
- DALI_TEST_EQUALS( b.angle, Radian( Math::PI_2 ), 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(b.angle, Radian(Math::PI_2), 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(b.axis, Vector3::ZAXIS, 0.001f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Radian r(Math::PI_2);
+ Radian r(Math::PI_2);
AngleAxis a(r, Vector3::ZAXIS);
AngleAxis b(a);
*
*/
-#include <iostream>
-#include <algorithm>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/actors/actor-devel.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/animation/animation-devel.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <algorithm>
+#include <iostream>
using std::max;
using namespace Dali;
namespace
{
-
static const float ROTATION_EPSILON = 0.0001f;
-static const float VECTOR4_EPSILON = 0.0001f;
-static const float VECTOR3_EPSILON = 0.0001f;
+static const float VECTOR4_EPSILON = 0.0001f;
+static const float VECTOR3_EPSILON = 0.0001f;
// Functor to test whether a Finish signal is emitted
struct AnimationFinishCheck
void CheckSignalReceived()
{
- if (!mSignalReceived)
+ if(!mSignalReceived)
{
tet_printf("Expected Finish signal was not received\n");
tet_result(TET_FAIL);
void CheckSignalNotReceived()
{
- if (mSignalReceived)
+ if(mSignalReceived)
{
tet_printf("Unexpected Finish signal was received\n");
tet_result(TET_FAIL);
{
AnimationProgressCheck(bool& signalReceived, std::string name = " ")
: mSignalReceived(signalReceived),
- mName( name )
+ mName(name)
{
}
void CheckSignalReceived()
{
- if (!mSignalReceived)
+ if(!mSignalReceived)
{
- tet_printf("Expected Progress reached signal was not received %s \n", mName.c_str() );
+ tet_printf("Expected Progress reached signal was not received %s \n", mName.c_str());
tet_result(TET_FAIL);
}
else
void CheckSignalNotReceived()
{
- if (mSignalReceived)
+ if(mSignalReceived)
{
tet_printf("Unexpected Progress reached signal was received %s \n", mName.c_str());
tet_result(TET_FAIL);
}
}
- bool& mSignalReceived; // owned by individual tests
+ bool& mSignalReceived; // owned by individual tests
std::string mName;
};
-} // anon namespace
+} // namespace
int UtcDaliAnimationConstructorP(void)
{
Animation animation;
- DALI_TEST_CHECK( !animation );
+ DALI_TEST_CHECK(!animation);
END_TEST;
}
{
TestApplication application;
- Animation animation = Animation::New( 1.0f );
+ Animation animation = Animation::New(1.0f);
DALI_TEST_CHECK(animation);
END_TEST;
{
TestApplication application;
- Animation animation = Animation::New( -1.0f );
+ Animation animation = Animation::New(-1.0f);
DALI_TEST_CHECK(animation);
DALI_TEST_EQUALS(animation.GetDuration(), 0.0f, TEST_LOCATION);
tet_infoline("Testing Dali::Animation::DownCast()");
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
BaseHandle object(animation);
Animation animation2 = Animation::DownCast(object);
DALI_TEST_CHECK(animation2);
- Animation animation3 = DownCast< Animation >(object);
+ Animation animation3 = DownCast<Animation>(object);
DALI_TEST_CHECK(animation3);
END_TEST;
}
BaseHandle unInitializedObject;
- Animation animation1 = Animation::DownCast( unInitializedObject );
- DALI_TEST_CHECK( !animation1 );
+ Animation animation1 = Animation::DownCast(unInitializedObject);
+ DALI_TEST_CHECK(!animation1);
- Animation animation2 = DownCast< Animation >( unInitializedObject );
- DALI_TEST_CHECK( !animation2 );
+ Animation animation2 = DownCast<Animation>(unInitializedObject);
+ DALI_TEST_CHECK(!animation2);
END_TEST;
}
TestApplication application;
// Initialize an object, ref count == 1
- Animation animation = Animation::New( 1.0f );
+ Animation animation = Animation::New(1.0f);
- Animation copy( animation );
- DALI_TEST_CHECK( copy );
+ Animation copy(animation);
+ DALI_TEST_CHECK(copy);
- DALI_TEST_CHECK( copy.GetDuration() == animation.GetDuration() );
+ DALI_TEST_CHECK(copy.GetDuration() == animation.GetDuration());
END_TEST;
}
{
TestApplication application;
- Animation animation = Animation::New( 1.0f );
+ Animation animation = Animation::New(1.0f);
Animation copy = animation;
- DALI_TEST_CHECK( copy );
+ DALI_TEST_CHECK(copy);
- DALI_TEST_CHECK( animation == copy );
+ DALI_TEST_CHECK(animation == copy);
- DALI_TEST_CHECK( copy.GetDuration() == animation.GetDuration() );
+ DALI_TEST_CHECK(copy.GetDuration() == animation.GetDuration());
END_TEST;
}
//Animation
- Animation animation = Animation::New( 1.0f );
- DALI_TEST_CHECK( animation );
- DALI_TEST_EQUALS( 1, animation.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.0f, animation.GetDuration(), 0.001f, TEST_LOCATION );
+ Animation animation = Animation::New(1.0f);
+ DALI_TEST_CHECK(animation);
+ DALI_TEST_EQUALS(1, animation.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.0f, animation.GetDuration(), 0.001f, TEST_LOCATION);
- Animation movedAnimation = std::move( animation );
- DALI_TEST_CHECK( movedAnimation );
- DALI_TEST_EQUALS( 1, movedAnimation.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.0f, movedAnimation.GetDuration(), 0.001f, TEST_LOCATION );
- DALI_TEST_CHECK( !animation );
+ Animation movedAnimation = std::move(animation);
+ DALI_TEST_CHECK(movedAnimation);
+ DALI_TEST_EQUALS(1, movedAnimation.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.0f, movedAnimation.GetDuration(), 0.001f, TEST_LOCATION);
+ DALI_TEST_CHECK(!animation);
// KeyFrames
KeyFrames keyframes = KeyFrames::New();
- DALI_TEST_CHECK( keyframes );
- DALI_TEST_EQUALS( 1, keyframes.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::Type::NONE, keyframes.GetType(), TEST_LOCATION );
+ DALI_TEST_CHECK(keyframes);
+ DALI_TEST_EQUALS(1, keyframes.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::Type::NONE, keyframes.GetType(), TEST_LOCATION);
- keyframes.Add( 0.0f, Vector3( 0.0f, 0.0f, 0.0f ) );
- keyframes.Add( 1.0f, Vector3( 100.0f, 100.0f, 100.0f ) );
- DALI_TEST_EQUALS( Property::Type::VECTOR3, keyframes.GetType(), TEST_LOCATION );
+ keyframes.Add(0.0f, Vector3(0.0f, 0.0f, 0.0f));
+ keyframes.Add(1.0f, Vector3(100.0f, 100.0f, 100.0f));
+ DALI_TEST_EQUALS(Property::Type::VECTOR3, keyframes.GetType(), TEST_LOCATION);
- KeyFrames movedKeyFrames = std::move( keyframes );
- DALI_TEST_CHECK( movedKeyFrames );
- DALI_TEST_EQUALS( 1, movedKeyFrames.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::Type::VECTOR3, movedKeyFrames.GetType(), TEST_LOCATION );
- DALI_TEST_CHECK( !keyframes );
+ KeyFrames movedKeyFrames = std::move(keyframes);
+ DALI_TEST_CHECK(movedKeyFrames);
+ DALI_TEST_EQUALS(1, movedKeyFrames.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::Type::VECTOR3, movedKeyFrames.GetType(), TEST_LOCATION);
+ DALI_TEST_CHECK(!keyframes);
END_TEST;
}
// Animation
- Animation animation = Animation::New( 1.0f );
- DALI_TEST_CHECK( animation );
- DALI_TEST_EQUALS( 1, animation.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.0f, animation.GetDuration(), 0.001f, TEST_LOCATION );
+ Animation animation = Animation::New(1.0f);
+ DALI_TEST_CHECK(animation);
+ DALI_TEST_EQUALS(1, animation.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.0f, animation.GetDuration(), 0.001f, TEST_LOCATION);
Animation move;
- move = std::move( animation );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.0f, move.GetDuration(), 0.001f, TEST_LOCATION );
- DALI_TEST_CHECK( !animation );
+ move = std::move(animation);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.0f, move.GetDuration(), 0.001f, TEST_LOCATION);
+ DALI_TEST_CHECK(!animation);
// KeyFrames
KeyFrames keyframes = KeyFrames::New();
- DALI_TEST_CHECK( keyframes );
- DALI_TEST_EQUALS( 1, keyframes.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::Type::NONE, keyframes.GetType(), TEST_LOCATION );
+ DALI_TEST_CHECK(keyframes);
+ DALI_TEST_EQUALS(1, keyframes.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::Type::NONE, keyframes.GetType(), TEST_LOCATION);
- keyframes.Add( 0.0f, Vector3( 0.0f, 0.0f, 0.0f ) );
- keyframes.Add( 1.0f, Vector3( 100.0f, 100.0f, 100.0f ) );
- DALI_TEST_EQUALS( Property::Type::VECTOR3, keyframes.GetType(), TEST_LOCATION );
+ keyframes.Add(0.0f, Vector3(0.0f, 0.0f, 0.0f));
+ keyframes.Add(1.0f, Vector3(100.0f, 100.0f, 100.0f));
+ DALI_TEST_EQUALS(Property::Type::VECTOR3, keyframes.GetType(), TEST_LOCATION);
KeyFrames movedKeyFrames;
- movedKeyFrames = std::move( keyframes );
- DALI_TEST_CHECK( movedKeyFrames );
- DALI_TEST_EQUALS( 1, movedKeyFrames.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::Type::VECTOR3, movedKeyFrames.GetType(), TEST_LOCATION );
- DALI_TEST_CHECK( !keyframes );
+ movedKeyFrames = std::move(keyframes);
+ DALI_TEST_CHECK(movedKeyFrames);
+ DALI_TEST_EQUALS(1, movedKeyFrames.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::Type::VECTOR3, movedKeyFrames.GetType(), TEST_LOCATION);
+ DALI_TEST_CHECK(!keyframes);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
DALI_TEST_EQUALS(animation.GetDuration(), durationSeconds, TEST_LOCATION);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) - 1u /*just less than the animation duration*/);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(2u/*just beyond the animation duration*/);
+ application.Render(2u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Restart the animation, with a different duration
finishCheck.Reset();
- actor.SetProperty( Actor::Property::POSITION, Vector3::ZERO );
+ actor.SetProperty(Actor::Property::POSITION, Vector3::ZERO);
durationSeconds = 3.5f;
animation.SetDuration(durationSeconds);
DALI_TEST_EQUALS(animation.GetDuration(), durationSeconds, TEST_LOCATION);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) - 1u/*just less than the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) - 1u /*just less than the animation duration*/);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(2u/*just beyond the animation duration*/);
+ application.Render(2u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Animation animation = Animation::New( 1.0f );
- DALI_TEST_EQUALS( animation.GetDuration(), 1.0f, TEST_LOCATION );
+ Animation animation = Animation::New(1.0f);
+ DALI_TEST_EQUALS(animation.GetDuration(), 1.0f, TEST_LOCATION);
- animation.SetDuration( -1.0f );
- DALI_TEST_EQUALS( animation.GetDuration(), 0.0f, TEST_LOCATION );
+ animation.SetDuration(-1.0f);
+ DALI_TEST_EQUALS(animation.GetDuration(), 0.0f, TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
DALI_TEST_CHECK(animation.IsLooping());
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
// Loop 5 times
float intervalSeconds = 0.25f;
- float progress = 0.0f;
- for (int iterations = 0; iterations < 5;)
+ float progress = 0.0f;
+ for(int iterations = 0; iterations < 5;)
{
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
progress += intervalSeconds;
- DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition * progress, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), 0.001f, TEST_LOCATION);
- if (progress >= 1.0f)
+ if(progress >= 1.0f)
{
progress = progress - 1.0f;
++iterations;
DALI_TEST_CHECK(!animation.IsLooping());
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
DALI_TEST_CHECK(animation.IsLooping());
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
// Loop
float intervalSeconds = 3.0f;
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.Render(0);
application.SendNotification();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
finishCheck.Reset();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.SetEndAction(Animation::DISCARD);
DALI_TEST_CHECK(animation.IsLooping());
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
float intervalSeconds = 3.0f;
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
application.SendNotification();
animation.SetLooping(true);
DALI_TEST_CHECK(animation.IsLooping());
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
animation.SetLooping(true);
DALI_TEST_CHECK(animation.IsLooping());
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
DALI_TEST_CHECK(animation.IsLooping());
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived(); // we never hit play
finishCheck.Reset();
-
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.SetEndAction(Animation::DISCARD);
float intervalSeconds = 3.0f;
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.SetLooping(true);
DALI_TEST_CHECK(animation.IsLooping());
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
DALI_TEST_CHECK(animation.IsLooping());
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived(); // we never hit play
finishCheck.Reset();
-
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.SetEndAction(Animation::BAKE);
float intervalSeconds = 3.0f;
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f) );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
finishCheck.Reset();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
DALI_TEST_CHECK(1 == animation.GetLoopCount());
// Loop
float intervalSeconds = 3.0f;
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.Render(0);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
animation.SetLoopCount(0);
END_TEST;
}
-
int UtcDaliAnimationGetCurrentLoopP(void)
{
TestApplication application;
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
DALI_TEST_CHECK(0 == animation.GetCurrentLoop());
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
// Loop
float intervalSeconds = 3.0f;
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
DALI_TEST_CHECK(2 == animation.GetCurrentLoop());
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
finishCheck.Reset();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalNotReceived();
DALI_TEST_CHECK(3 == animation.GetCurrentLoop());
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
DALI_TEST_CHECK(animation.GetEndAction() == Animation::BAKE);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Go back to the start
- actor.SetProperty( Actor::Property::POSITION, Vector3::ZERO );
+ actor.SetProperty(Actor::Property::POSITION, Vector3::ZERO);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3::ZERO, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Test BakeFinal, animate again, for half the duration
finishCheck.Reset();
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f*0.5f) /*half of the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f * 0.5f) /*half of the animation duration*/);
// Stop the animation early
animation.Stop();
// We did NOT expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( targetPosition * 0.5f, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), VECTOR4_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition * 0.5f, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), VECTOR4_EPSILON, TEST_LOCATION);
// The position should be same with target position in the next frame
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Go back to the start
- actor.SetProperty( Actor::Property::POSITION, Vector3::ZERO );
+ actor.SetProperty(Actor::Property::POSITION, Vector3::ZERO);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3::ZERO, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Test EndAction::Discard, animate again, but don't bake this time
finishCheck.Reset();
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// The position should be discarded in the next frame
application.Render(0);
- DALI_TEST_EQUALS( Vector3::ZERO/*discarded*/, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3::ZERO /*discarded*/, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3::ZERO, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( Vector3::ZERO, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3::ZERO, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationSetDisconnectActionP(void)
{
- TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
// Default: BakeFinal
{
stage.Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BAKE_FINAL);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /*Only half the animation*/);
actor.Unparent();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
// Bake
stage.Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetDisconnectAction( Animation::BAKE );
+ animation.SetDisconnectAction(Animation::BAKE);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /*Only half the animation*/);
actor.Unparent();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition*0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition * 0.5f, TEST_LOCATION);
}
// Discard
stage.Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetDisconnectAction( Animation::DISCARD );
+ animation.SetDisconnectAction(Animation::DISCARD);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /*Only half the animation*/);
actor.Unparent();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
}
// Don't play the animation: disconnect action should not be applied
stage.Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /*Only half the animation*/);
actor.Unparent();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
}
END_TEST;
int UtcDaliAnimationGetDisconnectActionP(void)
{
TestApplication application;
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
DALI_TEST_CHECK(animation.GetDisconnectAction() == Animation::BAKE_FINAL); // default!
animation.SetDisconnectAction(Animation::DISCARD);
{
TestApplication application;
- Animation animation = Animation::New(1.0f);
- AlphaFunction func = animation.GetDefaultAlphaFunction();
+ Animation animation = Animation::New(1.0f);
+ AlphaFunction func = animation.GetDefaultAlphaFunction();
DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
animation.SetDefaultAlphaFunction(AlphaFunction::EASE_IN);
{
TestApplication application;
- Animation animation = Animation::New(1.0f);
- AlphaFunction func = animation.GetDefaultAlphaFunction();
+ Animation animation = Animation::New(1.0f);
+ AlphaFunction func = animation.GetDefaultAlphaFunction();
// Test that the default is linear
DALI_TEST_EQUALS(func.GetBuiltinFunction(), AlphaFunction::DEFAULT, TEST_LOCATION);
float durationSeconds(1.0f);
animation.SetDuration(durationSeconds);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
- animation.SetCurrentProgress( 0.4f );
+ animation.SetCurrentProgress(0.4f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.6f), TEST_LOCATION );
- DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
+ DALI_TEST_EQUALS(0.6f, animation.GetCurrentProgress(), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
//Set the progress to 70%
- animation.SetCurrentProgress( 0.7f );
+ animation.SetCurrentProgress(0.7f);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 80% progress */);
- DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 80% progress */);
+ DALI_TEST_EQUALS(0.8f, animation.GetCurrentProgress(), TEST_LOCATION);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
- DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
+ DALI_TEST_EQUALS(0.8f, animation.GetCurrentProgress(), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
float durationSeconds(1.0f);
animation.SetDuration(durationSeconds);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
//Trying to set the current cursor outside the range [0..1] is ignored
- animation.SetCurrentProgress( -1.0f);
+ animation.SetCurrentProgress(-1.0f);
application.SendNotification();
- DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
- animation.SetCurrentProgress( 100.0f);
+ animation.SetCurrentProgress(100.0f);
application.SendNotification();
- DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
END_TEST;
}
animation.Play();
//Test GetCurrentProgress return 0.0 as the duration is 0.0
- DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
- animation.SetCurrentProgress( 0.5f );
+ animation.SetCurrentProgress(0.5f);
application.SendNotification();
application.Render(static_cast<unsigned int>(100.0f));
//Progress should still be 0.0
- DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
//Set duration
float durationSeconds(1.0f);
animation.SetDuration(durationSeconds);
application.SendNotification();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
- animation.SetCurrentProgress( 0.4f );
+ animation.SetCurrentProgress(0.4f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.6f, animation.GetCurrentProgress(), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
//Set the progress to 70%
- animation.SetCurrentProgress( 0.7f );
+ animation.SetCurrentProgress(0.7f);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 80% progress */);
- DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 80% progress */);
+ DALI_TEST_EQUALS(0.8f, animation.GetCurrentProgress(), TEST_LOCATION);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.8f, animation.GetCurrentProgress(), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.0f, initialPosition);
- keyframes.Add( 1.0f, targetPosition );
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(0.0f, initialPosition);
+ keyframes.Add(1.0f, targetPosition);
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
//Set speed to be x2
animation.SetSpeedFactor(2.0f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.4f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f) + 1u/*just beyond half the duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) + 1u /*just beyond half the duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.0f, initialPosition);
- keyframes.Add( 1.0f, targetPosition );
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(0.0f, initialPosition);
+ keyframes.Add(1.0f, targetPosition);
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
tet_printf("Test -1 speed factor. Animation will play in reverse at normal speed\n");
- animation.SetSpeedFactor( -1.0f );
+ animation.SetSpeedFactor(-1.0f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.6f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.4f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), initialPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), initialPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( initialPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( initialPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.0f, initialPosition);
- keyframes.Add( 1.0f, targetPosition );
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(0.0f, initialPosition);
+ keyframes.Add(1.0f, targetPosition);
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
tet_printf("Test half speed factor. Animation will take twice the duration\n");
//Set speed to be half of normal speed
- animation.SetSpeedFactor( 0.5f );
+ animation.SetSpeedFactor(0.5f);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 10% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.1f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.1f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 30% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.3f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.3f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.4f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*1200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliAnimationSetSpeedFactorP4(void)
{
TestApplication application;
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
const Vector3 initialPosition(0.0f, 0.0f, 0.0f);
const Vector3 targetPosition(100.0f, 100.0f, 100.0f);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.0f, initialPosition);
- keyframes.Add( 1.0f, targetPosition );
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(0.0f, initialPosition);
+ keyframes.Add(1.0f, targetPosition);
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
tet_printf("Set speed to be half of normal speed\n");
tet_printf("SetSpeedFactor(0.5f)\n");
- animation.SetSpeedFactor( 0.5f );
+ animation.SetSpeedFactor(0.5f);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 10% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.1f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.1f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 30% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.3f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.3f), TEST_LOCATION);
tet_printf("Reverse direction of animation whilst playing\n");
tet_printf("SetSpeedFactor(-0.5f)\n");
animation.SetSpeedFactor(-0.5f);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 10% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.1f), 0.0001, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.1f), 0.0001, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), initialPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), initialPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( initialPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( initialPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
/* | reverse */
- { 0.0f, 1.0f, // TimePeriod
- 0.0f, 100.0f, // POS
- {/**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, /* Loop */
- /**/ 30.0f, 40.0f, 50.0f, 60.0f, /* Reverse direction */
- /**/ 50.0f,
- /**/ 40.0f,
- /**/ 30.0f,
- /**/ 70.0f,
- /**/ 60.0f,
- /**/ 50.0f,
+ {0.0f, 1.0f, // TimePeriod
+ 0.0f,
+ 100.0f, // POS
+ {
+ /**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, /* Loop */
+ /**/ 30.0f,
+ 40.0f,
+ 50.0f,
+ 60.0f, /* Reverse direction */
+ /**/ 50.0f,
+ /**/ 40.0f,
+ /**/ 30.0f,
+ /**/ 70.0f,
+ /**/ 60.0f,
+ /**/ 50.0f,
/**/
- }
- },
+ }},
// ACTOR 1 - Across start of range
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
/* | reverse */
- { 0.2f, 0.5f, // TimePeriod
- 20.0f, 50.0f, // POS
- {/**/ 30.0f, 40.0f, 50.0f, 50.0f, 50.0f, /* Loop */
- /**/ 30.0f, 40.0f, 50.0f, 50.0f, /* Reverse direction @ frame #9 */
- /**/ 50.0f,
- /**/ 40.0f,
- /**/ 30.0f,
- /**/ 50.0f,
- /**/ 50.0f,
- /**/ 50.0f
- }
- },
+ {0.2f, 0.5f, // TimePeriod
+ 20.0f,
+ 50.0f, // POS
+ {/**/ 30.0f, 40.0f, 50.0f, 50.0f, 50.0f, /* Loop */
+ /**/ 30.0f,
+ 40.0f,
+ 50.0f,
+ 50.0f, /* Reverse direction @ frame #9 */
+ /**/ 50.0f,
+ /**/ 40.0f,
+ /**/ 30.0f,
+ /**/ 50.0f,
+ /**/ 50.0f,
+ /**/ 50.0f}},
// ACTOR 2 - Across end of range
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
/* | reverse */
- {/**/ 0.5f, 0.9f, // TimePeriod
- /**/ 50.0f, 90.0f, // POS
- { /**/ 50.0f, 50.0f, 50.0f, 60.0f, 70.0f, /* Loop */
- /**/ 50.0f, 50.0f, 50.0f, 60.0f,/* Reverse direction @ frame #9 */
- /**/ 50.0f,
- /**/ 50.0f,
- /**/ 50.0f, 70.0f,
- /**/ 60.0f,
- /**/ 50.0f,
- }
- },
+ {/**/ 0.5f, 0.9f, // TimePeriod
+ /**/ 50.0f,
+ 90.0f, // POS
+ {
+ /**/ 50.0f,
+ 50.0f,
+ 50.0f,
+ 60.0f,
+ 70.0f, /* Loop */
+ /**/ 50.0f,
+ 50.0f,
+ 50.0f,
+ 60.0f, /* Reverse direction @ frame #9 */
+ /**/ 50.0f,
+ /**/ 50.0f,
+ /**/ 50.0f,
+ 70.0f,
+ /**/ 60.0f,
+ /**/ 50.0f,
+ }},
// ACTOR 3 - Before beginning of range
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
/* | reverse */
- {/**/ 0.1f, 0.25f, // TimePeriod
- /**/ 10.0f, 25.0f, // POS
- { /**/
- /**/ 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f, 25.0f
+ {/**/ 0.1f, 0.25f, // TimePeriod
+ /**/ 10.0f,
+ 25.0f, // POS
+ {
/**/
- }
- },
+ /**/ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f,
+ 25.0f
+ /**/
+ }},
// ACTOR 4 - After end of range
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
/* | reverse */
- {/**/ 0.85f, 1.0f, // TimePeriod
- /**/ 85.0f, 100.0f, // POS
- { /**/
- /**/ 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f, 85.0f
+ {/**/ 0.85f, 1.0f, // TimePeriod
+ /**/ 85.0f,
+ 100.0f, // POS
+ {
/**/
- }
- },
+ /**/ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f,
+ 85.0f
+ /**/
+ }},
// Actor 5 - Middle of range
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
/* | reverse */
- {/**/ 0.4f, 0.65f, // Time Period
- /**/ 40.0f, 65.0f, // Position
- { /**/ 40.0f, 40.0f, 50.0f, 60.0f, 65.0f,
- /**/ 40.0f, 40.0f, 50.0f, 60.0f, // Reverse
- /**/ 50.0f,
- /**/ 40.0f,
- /**/ 40.0f,
- /**/ 65.0f,
- /**/ 60.0f,
- /**/ 50.0f,
- }
- }
- };
-
- const size_t NUM_ENTRIES(sizeof(testData)/sizeof(TestData));
-
- // Build the animation
- float durationSeconds(1.0f);
- Animation animation = Animation::New(durationSeconds);
- bool signalReceived(false);
+ {/**/ 0.4f, 0.65f, // Time Period
+ /**/ 40.0f,
+ 65.0f, // Position
+ {
+ /**/ 40.0f,
+ 40.0f,
+ 50.0f,
+ 60.0f,
+ 65.0f,
+ /**/ 40.0f,
+ 40.0f,
+ 50.0f,
+ 60.0f, // Reverse
+ /**/ 50.0f,
+ /**/ 40.0f,
+ /**/ 40.0f,
+ /**/ 65.0f,
+ /**/ 60.0f,
+ /**/ 50.0f,
+ }}};
+
+ const size_t NUM_ENTRIES(sizeof(testData) / sizeof(TestData));
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
std::vector<Dali::Actor> actors;
- for( unsigned int actorIndex = 0; actorIndex < NUM_ENTRIES; ++actorIndex )
+ for(unsigned int actorIndex = 0; actorIndex < NUM_ENTRIES; ++actorIndex)
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::POSITION, Vector3( testData[actorIndex].startX, 0, 0 ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(testData[actorIndex].startX, 0, 0));
actors.push_back(actor);
application.GetScene().Add(actor);
- if( actorIndex == 0 || actorIndex == NUM_ENTRIES-1 )
+ if(actorIndex == 0 || actorIndex == NUM_ENTRIES - 1)
{
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( testData[actorIndex].startTime, Vector3(testData[actorIndex].startX, 0, 0));
- keyframes.Add( testData[actorIndex].endTime, Vector3(testData[actorIndex].endX, 0, 0));
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(testData[actorIndex].startTime, Vector3(testData[actorIndex].startX, 0, 0));
+ keyframes.Add(testData[actorIndex].endTime, Vector3(testData[actorIndex].endX, 0, 0));
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
}
else
{
- animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( testData[actorIndex].endX, 0, 0 ), TimePeriod( testData[actorIndex].startTime, testData[actorIndex].endTime - testData[actorIndex].startTime) );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(testData[actorIndex].endX, 0, 0), TimePeriod(testData[actorIndex].startTime, testData[actorIndex].endTime - testData[actorIndex].startTime));
}
}
tet_printf("Test half speed factor. Animation will take twice the duration\n");
tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
tet_printf("SetSpeedFactor(0.5f)\n");
- animation.SetSpeedFactor( 0.5f );
- animation.SetPlayRange( Vector2(0.3f, 0.8f) );
+ animation.SetSpeedFactor(0.5f);
+ animation.SetPlayRange(Vector2(0.3f, 0.8f));
animation.SetLooping(true);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(0); // Frame 0 tests initial values
+ application.Render(0); // Frame 0 tests initial values
- for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
+ for(unsigned int frame = 0; frame < NUM_FRAMES; ++frame)
{
unsigned int actorIndex = 0u;
- for( actorIndex = 0u; actorIndex < NUM_ENTRIES; ++actorIndex )
+ for(actorIndex = 0u; actorIndex < NUM_ENTRIES; ++actorIndex)
{
- DALI_TEST_EQUALS( actors[actorIndex].GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, testData[actorIndex].expected[frame], 0.001, TEST_LOCATION );
- if( ! Equals(actors[actorIndex].GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, testData[actorIndex].expected[frame]) )
+ DALI_TEST_EQUALS(actors[actorIndex].GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, testData[actorIndex].expected[frame], 0.001, TEST_LOCATION);
+ if(!Equals(actors[actorIndex].GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, testData[actorIndex].expected[frame]))
{
- tet_printf("Failed at frame %u, actorIndex %u\n", frame, actorIndex );
+ tet_printf("Failed at frame %u, actorIndex %u\n", frame, actorIndex);
}
}
- if( frame == 8 )
+ if(frame == 8)
{
tet_printf("Reverse direction of animation whilst playing after frame 8\n");
tet_printf("SetSpeedFactor(-0.5f)\n");
// ACTOR 0
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
- { 0.0f, 1.0f, // TimePeriod
- 0.0f, 100.0f, // POS
- {/**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, /* Loop */
- /**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,
- /**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f,
+ {0.0f, 1.0f, // TimePeriod
+ 0.0f,
+ 100.0f, // POS
+ {
+ /**/ 30.0f, 40.0f, 50.0f, 60.0f, 70.0f, /* Loop */
+ /**/ 30.0f,
+ 40.0f,
+ 50.0f,
+ 60.0f,
+ 70.0f,
+ /**/ 30.0f,
+ 40.0f,
+ 50.0f,
+ 60.0f,
+ 70.0f,
/**/
- }
- };
-
+ }};
// Build the animation
- float durationSeconds(1.0f);
- Animation animation = Animation::New(durationSeconds);
- bool signalReceived(false);
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
std::vector<Dali::Actor> actors;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::POSITION, Vector3( testData.startX, 0, 0 ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(testData.startX, 0, 0));
actors.push_back(actor);
application.GetScene().Add(actor);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( testData.startTime, Vector3(testData.startX, 0, 0));
- keyframes.Add( testData.endTime, Vector3(testData.endX, 0, 0));
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(testData.startTime, Vector3(testData.startX, 0, 0));
+ keyframes.Add(testData.endTime, Vector3(testData.endX, 0, 0));
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
tet_printf("Test half speed factor. Animation will take twice the duration\n");
tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
tet_printf("SetSpeedFactor(0.5f)\n");
tet_printf("SetLoopCount(3)\n");
- animation.SetSpeedFactor( 0.5f );
- animation.SetPlayRange( Vector2(0.3f, 0.8f) );
+ animation.SetSpeedFactor(0.5f);
+ animation.SetPlayRange(Vector2(0.3f, 0.8f));
animation.SetLoopCount(3);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(0); // Frame 0 tests initial values
+ application.Render(0); // Frame 0 tests initial values
- for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
+ for(unsigned int frame = 0; frame < NUM_FRAMES; ++frame)
{
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, testData.expected[frame], 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, testData.expected[frame], 0.001, TEST_LOCATION);
application.Render(200); // 200 ms at half speed corresponds to 0.1 s
- if( frame < NUM_FRAMES-1 )
+ if(frame < NUM_FRAMES - 1)
{
// We didn't expect the animation to finish yet
application.SendNotification();
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, 80.0f, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, 80.0f, 0.001, TEST_LOCATION);
END_TEST;
}
// ACTOR 0
/*0.0f, 0.1f 0.2f 0.3f 0.4f 0.5f 0.6f 0.7f 0.8f 0.9f 1.0f */
/* |----------PlayRange---------------| */
- { 0.0f, 1.0f, // TimePeriod
- 0.0f, 100.0f, // POS
- {/**/ 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
- /**/ 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
- /**/ 80.0f, 70.0f, 60.0f, 50.0f, 40.0f,
- }
- };
-
-
- // Build the animation
- float durationSeconds(1.0f);
- Animation animation = Animation::New(durationSeconds);
- bool signalReceived(false);
+ {0.0f, 1.0f, // TimePeriod
+ 0.0f,
+ 100.0f, // POS
+ {
+ /**/ 80.0f,
+ 70.0f,
+ 60.0f,
+ 50.0f,
+ 40.0f,
+ /**/ 80.0f,
+ 70.0f,
+ 60.0f,
+ 50.0f,
+ 40.0f,
+ /**/ 80.0f,
+ 70.0f,
+ 60.0f,
+ 50.0f,
+ 40.0f,
+ }};
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
std::vector<Dali::Actor> actors;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::POSITION, Vector3( testData.startX, 0, 0 ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(testData.startX, 0, 0));
actors.push_back(actor);
application.GetScene().Add(actor);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( testData.startTime, Vector3(testData.startX, 0, 0));
- keyframes.Add( testData.endTime, Vector3(testData.endX, 0, 0));
- animation.AnimateBetween( Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
+ keyframes.Add(testData.startTime, Vector3(testData.startX, 0, 0));
+ keyframes.Add(testData.endTime, Vector3(testData.endX, 0, 0));
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, AlphaFunction::LINEAR);
tet_printf("Test reverse half speed factor. Animation will take twice the duration\n");
tet_printf("Set play range to be 0.3 - 0.8 of the duration\n");
tet_printf("SetSpeedFactor(-0.5f)\n");
tet_printf("SetLoopCount(3)\n");
- animation.SetSpeedFactor( -0.5f );
- animation.SetPlayRange( Vector2(0.3f, 0.8f) );
+ animation.SetSpeedFactor(-0.5f);
+ animation.SetPlayRange(Vector2(0.3f, 0.8f));
animation.SetLoopCount(3);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(0); // Frame 0 tests initial values
+ application.Render(0); // Frame 0 tests initial values
- for( unsigned int frame = 0; frame < NUM_FRAMES; ++frame )
+ for(unsigned int frame = 0; frame < NUM_FRAMES; ++frame)
{
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, testData.expected[frame], 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, testData.expected[frame], 0.001, TEST_LOCATION);
application.Render(200); // 200 ms at half speed corresponds to 0.1 s
- if( frame < NUM_FRAMES-1 )
+ if(frame < NUM_FRAMES - 1)
{
// We didn't expect the animation to finish yet
application.SendNotification();
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, 30.0f, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, 30.0f, 0.001, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliAnimationGetSpeedFactorP(void)
{
TestApplication application;
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Build the animation
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
// Set range between 0.4 and 0.8
- animation.SetPlayRange( Vector2( 0.4f, 0.9f ) );
+ animation.SetPlayRange(Vector2(0.4f, 0.9f));
application.SendNotification();
- DALI_TEST_EQUALS( Vector2( 0.4f, 0.9f ), animation.GetPlayRange(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector2(0.4f, 0.9f), animation.GetPlayRange(), TEST_LOCATION);
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
animation.Play();
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 200.0f )/* 60% progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.6f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 200.0f )/* 80% progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.8f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds*100.0f ) + 1u/*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.9f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.9f), TEST_LOCATION);
END_TEST;
}
application.SendNotification();
//PlayRange out of bounds
- animation.SetPlayRange( Vector2(-1.0f,1.0f) );
+ animation.SetPlayRange(Vector2(-1.0f, 1.0f));
application.SendNotification();
- DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
- animation.SetPlayRange( Vector2(0.0f,2.0f) );
+ DALI_TEST_EQUALS(Vector2(0.0f, 1.0f), animation.GetPlayRange(), TEST_LOCATION);
+ animation.SetPlayRange(Vector2(0.0f, 2.0f));
application.SendNotification();
- DALI_TEST_EQUALS( Vector2(0.0f,1.0f), animation.GetPlayRange(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector2(0.0f, 1.0f), animation.GetPlayRange(), TEST_LOCATION);
//If playRange is not in the correct order it has to be ordered
- animation.SetPlayRange( Vector2(0.8f,0.2f) );
+ animation.SetPlayRange(Vector2(0.8f, 0.2f));
application.SendNotification();
- DALI_TEST_EQUALS( Vector2(0.2f,0.8f), animation.GetPlayRange(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector2(0.2f, 0.8f), animation.GetPlayRange(), TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Build the animation
- Animation animation = Animation::New( 1.0f );
+ Animation animation = Animation::New(1.0f);
application.SendNotification();
//If PlayRange not specified it should be 0.0-1.0 by default
- DALI_TEST_EQUALS( Vector2( 0.0f,1.0f ), animation.GetPlayRange(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector2(0.0f, 1.0f), animation.GetPlayRange(), TEST_LOCATION);
// Set range between 0.4 and 0.8
- animation.SetPlayRange( Vector2( 0.4f, 0.8f ) );
+ animation.SetPlayRange(Vector2(0.4f, 0.8f));
application.SendNotification();
- DALI_TEST_EQUALS( Vector2( 0.4f, 0.8f ), animation.GetPlayRange(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector2(0.4f, 0.8f), animation.GetPlayRange(), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.4f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.6f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
+ END_TEST;
+}
+
+int UtcDaliAnimationPlayOffSceneP(void)
+{
+ // Test that an animation cannot be played, when the actor is off-stage.
+ // And the property value and the current property value should not be changed in the case.
+
+ TestApplication application;
+
+ Actor actor = Actor::New();
+ Vector3 basePosition(Vector3::ZERO);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
+ // Not added to the stage yet!
+
+ // Build the animation
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ // Start the animation
+ animation.Play();
+
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ // An animation can't be played. The position shouldn't be changed.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
+
+ // Add to the stage
+ application.GetScene().Add(actor);
+
+ // Start the animation again
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ // We did expect the animation to finish
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+
+ // Reset the position
+ actor[Actor::Property::POSITION] = basePosition;
+
+ application.SendNotification();
+ application.Render();
+
+ // Create an animator again
+ animation.Clear();
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
+
+ // Remove from the stage
+ application.GetScene().Remove(actor);
+
+ signalReceived = false;
+
+ // Start the animation again
+ animation.Play();
+
+ application.SendNotification();
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
+
+ application.SendNotification();
+ finishCheck.CheckSignalReceived();
+
+ // An animation can't be played. The position shouldn't be changed.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
+
END_TEST;
}
int UtcDaliAnimationPlayOffSceneDiscardP(void)
{
- // Test that an animation can be played, when the actor is off-stage.
+ // Test that an animation cannot be played, when the actor is off-stage.
// When the actor is added to the stage, it should appear at the current position
// i.e. where it would have been anyway, if on-stage from the beginning.
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 basePosition(Vector3::ZERO);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), basePosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
// Not added to the stage yet!
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetDisconnectAction( Animation::DISCARD );
+ animation.SetDisconnectAction(Animation::DISCARD);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(20,20,20), TEST_LOCATION );
+
+ // An animation can't be played. The position shouldn't be changed.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
// Add to the stage
application.GetScene().Add(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(40,40,40)/*on-stage*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(40, 40, 40) /*on-stage*/, TEST_LOCATION);
// Remove from the stage
application.GetScene().Remove(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO/*back to start position as disconnect behaviour is discard*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO /*back to start position as disconnect behaviour is discard*/, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Add to the stage
application.GetScene().Add(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(80,80,80), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(80, 80, 80), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
-
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationPlayOffSceneBakeFinalP(void)
{
- // Test that an animation can be played, when the actor is off-stage.
+ // Test that an animation cannot be played, when the actor is off-stage.
// When the actor is added to the stage, it should appear at the current position
// i.e. where it would have been anyway, if on-stage from the beginning.
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 basePosition(Vector3::ZERO);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), basePosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
// Not added to the stage!
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(20,20,20), TEST_LOCATION );
+
+ // An animation can't be played. The position shouldn't be changed.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
// Add to the stage
application.GetScene().Add(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(40,40,40)/*on-stage*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(40, 40, 40) /*on-stage*/, TEST_LOCATION);
// Remove from the stage
application.GetScene().Remove(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition /*bake final*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition /*bake final*/, TEST_LOCATION);
// Add to the stage
application.GetScene().Add(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition /*bake final removed the */, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition /*bake final removed the */, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationPlayOffSceneBakeP(void)
{
- // Test that an animation can be played, when the actor is off-stage.
+ // Test that an animation cannot be played, when the actor is off-stage.
// When the actor is added to the stage, it should appear at the current position
// i.e. where it would have been anyway, if on-stage from the beginning.
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 basePosition(Vector3::ZERO);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), basePosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
// Not added to the stage!
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetDisconnectAction( Animation::BAKE );
+ animation.SetDisconnectAction(Animation::BAKE);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(20,20,20), TEST_LOCATION );
+
+ // An animation can't be played. The position shouldn't be changed.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), basePosition, TEST_LOCATION);
// Add to the stage
application.GetScene().Add(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(40,40,40)/*on-stage*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(40, 40, 40) /*on-stage*/, TEST_LOCATION);
// Remove from the stage
application.GetScene().Remove(actor); // baked here
application.SendNotification();
// this render is a no-op in this case as animator is disabled while off stage
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(40,40,40) /*baked value*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(40, 40, 40) /*baked value*/, TEST_LOCATION);
// Add back to the stage
application.GetScene().Add(actor);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) /* animation restarted at 40,40,40 + 80%*60 */, TEST_LOCATION );
- application.Render(static_cast<unsigned int>(0.0f) );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) /*baked value*/, TEST_LOCATION );
- application.Render(static_cast<unsigned int>(0.0f) );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) /*baked value*/, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88) /* animation restarted at 40,40,40 + 80%*60 */, TEST_LOCATION);
+ application.Render(static_cast<unsigned int>(0.0f));
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88) /*baked value*/, TEST_LOCATION);
+ application.Render(static_cast<unsigned int>(0.0f));
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88) /*baked value*/, TEST_LOCATION);
// Remove from the stage
application.GetScene().Remove(actor); // baked here
application.SendNotification();
// this render is a no-op in this case as animator is disabled while off stage
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) /*baked value*/, TEST_LOCATION );
- application.Render(static_cast<unsigned int>(0.0f) );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) /*baked value*/, TEST_LOCATION );
- application.Render(static_cast<unsigned int>(0.0f) );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) /*baked value*/, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 100% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88) /*baked value*/, TEST_LOCATION);
+ application.Render(static_cast<unsigned int>(0.0f));
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88) /*baked value*/, TEST_LOCATION);
+ application.Render(static_cast<unsigned int>(0.0f));
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88) /*baked value*/, TEST_LOCATION);
// Add back to the stage
application.GetScene().Add(actor);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(88,88,88) , TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(88, 88, 88), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
// This is a test of the "Fire and Forget" behaviour
// Discard the animation handle!
animation.Reset();
- DALI_TEST_CHECK( !animation );
+ DALI_TEST_CHECK(!animation);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.4f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.6f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
// This is a test of the "Fire and Forget" behaviour
// Stop the animation, and Discard the animation handle!
animation.Stop();
animation.Reset();
- DALI_TEST_CHECK( !animation );
+ DALI_TEST_CHECK(!animation);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
// We expect the animation to finish at 20% progress
application.SendNotification();
finishCheck.CheckSignalReceived();
finishCheck.Reset();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// Check that nothing has changed
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// Check that nothing has changed
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 100% progress */);
// Check that nothing has changed
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.2f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.2f), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.0f , Vector3(0.0f,0.0f,0.0f ) );
- keyframes.Add( 1.0f , Vector3(100.0f,100.0f,100.0f ) );
+ keyframes.Add(0.0f, Vector3(0.0f, 0.0f, 0.0f));
+ keyframes.Add(1.0f, Vector3(100.0f, 100.0f, 100.0f));
- animation.AnimateBetween( Property( actor, Actor::Property::POSITION), keyframes );
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes);
// Set range between 0.4 and 0.8
- animation.SetPlayRange( Vector2(0.4f,0.8f) );
+ animation.SetPlayRange(Vector2(0.4f, 0.8f));
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
//Test that setting progress outside the range doesn't work
- animation.SetCurrentProgress( 0.9f );
+ animation.SetCurrentProgress(0.9f);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
- animation.SetCurrentProgress( 0.2f );
+ DALI_TEST_EQUALS(animation.GetCurrentProgress(), 0.4f, TEST_LOCATION);
+ animation.SetCurrentProgress(0.2f);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( animation.GetCurrentProgress(), 0.4f, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetCurrentProgress(), 0.4f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.6f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /* 80% progress */);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition * 0.8f, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition * 0.8f, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
-
+ DALI_TEST_EQUALS(targetPosition * 0.8f, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
//Loop inside the range
finishCheck.Reset();
- animation.SetLooping( true );
+ animation.SetLooping(true);
animation.Play();
application.SendNotification();
float intervalSeconds = 0.1f;
- float progress = 0.4f;
- for (int iterations = 0; iterations < 10; ++iterations )
+ float progress = 0.4f;
+ for(int iterations = 0; iterations < 10; ++iterations)
{
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
progress += intervalSeconds;
- if (progress > 0.8f)
+ if(progress > 0.8f)
{
progress = progress - 0.4f;
}
- DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition * progress, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), 0.001f, TEST_LOCATION);
}
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
-
//Test change range on the fly
- animation.SetPlayRange( Vector2( 0.2f, 0.9f ) );
+ animation.SetPlayRange(Vector2(0.2f, 0.9f));
application.SendNotification();
- for (int iterations = 0; iterations < 10; ++iterations )
+ for(int iterations = 0; iterations < 10; ++iterations)
{
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
progress += intervalSeconds;
- if (progress > 0.9f)
+ if(progress > 0.9f)
{
progress = progress - 0.7f;
}
- DALI_TEST_EQUALS( targetPosition*progress, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition * progress, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), 0.001f, TEST_LOCATION);
}
END_TEST;
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation from 40% progress
- animation.PlayFrom( 0.4f );
+ animation.PlayFrom(0.4f);
// Target value should be updated straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.6f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.6f), TEST_LOCATION);
animation.Play(); // Test that calling play has no effect, when animation is already playing
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), (targetPosition * 0.8f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.8f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
//PlayFrom with an argument outside the range [0..1] will be ignored
animation.PlayFrom(-1.0f);
application.SendNotification();
- DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
animation.PlayFrom(100.0f);
application.SendNotification();
- DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress, TEST_LOCATION);
// Pause the animation
animation.Pause();
application.SendNotification();
// Loop 5 times
- for (int i=0; i<5; ++i)
+ for(int i = 0; i < 5; ++i)
{
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress /* Still 50% progress when paused */, TEST_LOCATION);
}
// Keep going
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 490.0f) /*slightly less than the animation duration*/);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliAnimationGetStateP(void)
{
TestApplication application;
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::STOPPED, TEST_LOCATION);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
// Start the animation
animation.Play();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress, TEST_LOCATION);
// Pause the animation
animation.Pause();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PAUSED, TEST_LOCATION);
application.SendNotification();
application.Render(0.f);
// Loop 5 times
- for (int i=0; i<5; ++i)
+ for(int i = 0; i < 5; ++i)
{
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress/* Still 50% progress when paused */, TEST_LOCATION );
- DALI_TEST_EQUALS( animation.GetState(), Animation::PAUSED, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress /* Still 50% progress when paused */, TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PAUSED, TEST_LOCATION);
}
// Keep going
finishCheck.Reset();
animation.Play();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 490.0f) /*slightly less than the animation duration*/);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetState(), Animation::STOPPED, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( targetPosition, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
- DALI_TEST_EQUALS( animation.GetState(), Animation::STOPPED, TEST_LOCATION );
+ DALI_TEST_EQUALS(targetPosition, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetState(), Animation::STOPPED, TEST_LOCATION);
// re-play
finishCheck.Reset();
animation.Play();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*490.0f)/*slightly less than the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 490.0f) /*slightly less than the animation duration*/);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress, TEST_LOCATION);
// Stop the animation
animation.Stop();
application.SendNotification();
// Loop 5 times
- for (int i=0; i<5; ++i)
+ for(int i = 0; i < 5; ++i)
{
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress/* Still 50% progress when stopped */, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress /* Still 50% progress when stopped */, TEST_LOCATION);
}
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress, TEST_LOCATION);
// Stop the animation
animation.Stop();
Vector3 positionSet(2.0f, 3.0f, 4.0f);
- actor.SetProperty( Actor::Property::POSITION, positionSet );
+ actor.SetProperty(Actor::Property::POSITION, positionSet);
application.SendNotification();
// Loop 5 times
- for (int i=0; i<5; ++i)
+ for(int i = 0; i < 5; ++i)
{
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), positionSet/*Animation should not interfere with this*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), positionSet /*Animation should not interfere with this*/, TEST_LOCATION);
}
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
Vector3 fiftyPercentProgress(targetPosition * 0.5f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress, TEST_LOCATION);
// Clear the animation
animation.Clear();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We don't expect the animation to finish now
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), fiftyPercentProgress/* Still 50% progress since the animator was destroyed */, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), fiftyPercentProgress /* Still 50% progress since the animator was destroyed */, TEST_LOCATION);
// Restart as a scale animation; this should not move the actor's position
finishCheck.Reset();
- actor.SetProperty( Actor::Property::POSITION, Vector3::ZERO );
+ actor.SetProperty(Actor::Property::POSITION, Vector3::ZERO);
Vector3 targetScale(3.0f, 3.0f, 3.0f);
- animation.AnimateTo( Property( actor, Actor::Property::SCALE ), targetScale, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO/*Check move-animator was destroyed*/, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3(2.0f, 2.0f, 2.0f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO /*Check move-animator was destroyed*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3(2.0f, 2.0f, 2.0f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO/*Check move-animator was destroyed*/, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO /*Check move-animator was destroyed*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
END_TEST;
}
TestApplication application;
// Start the empty animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
Actor actor = Actor::New();
// Register a boolean property
- bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
- Animation animation = Animation::New(durationSeconds);
+ float durationSeconds(2.0f);
+ Animation animation = Animation::New(durationSeconds);
const bool relativeValue(true);
- const bool finalValue( false || relativeValue );
+ const bool finalValue(false || relativeValue);
animation.AnimateBy(Property(actor, index), relativeValue);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< bool >( index ), finalValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(index), finalValue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Repeat with relative value "false" - this should be an NOOP
animation = Animation::New(durationSeconds);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- bool relativeValue(true);
- bool finalValue( false || relativeValue );
+ bool relativeValue(true);
+ bool finalValue(false || relativeValue);
animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_IN);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Repeat with relative value "false" - this should be an NOOP
animation = Animation::New(durationSeconds);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- bool relativeValue(true);
- bool finalValue( false || relativeValue );
- float animatorDurationSeconds(durationSeconds * 0.5f);
- animation.AnimateBy( Property(actor, index),
- relativeValue,
- TimePeriod( animatorDurationSeconds ) );
+ bool relativeValue(true);
+ bool finalValue(false || relativeValue);
+ float animatorDurationSeconds(durationSeconds * 0.5f);
+ animation.AnimateBy(Property(actor, index),
+ relativeValue,
+ TimePeriod(animatorDurationSeconds));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 950.0f) /* 95% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 50.0f) + 1u /*just beyond the animator duration*/);
// We didn't expect the animation to finish yet...
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// ...however we should have reached the final value
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 1000.0f) /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- bool relativeValue(true);
- bool finalValue( false || relativeValue );
- float animatorDurationSeconds(durationSeconds * 0.5f);
- animation.AnimateBy( Property(actor, index),
- relativeValue,
- AlphaFunction::EASE_IN_OUT,
- TimePeriod( animatorDurationSeconds ) );
+ bool relativeValue(true);
+ bool finalValue(false || relativeValue);
+ float animatorDurationSeconds(durationSeconds * 0.5f);
+ animation.AnimateBy(Property(actor, index),
+ relativeValue,
+ AlphaFunction::EASE_IN_OUT,
+ TimePeriod(animatorDurationSeconds));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 950.0f) /* 95% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 50.0f) + 1u /*just beyond the animator duration*/);
// We didn't expect the animation to finish yet...
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// ...however we should have reached the final value
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 1000.0f) /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(50.0f);
- float relativeValue(targetValue - startValue);
+ float targetValue(50.0f);
+ float relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue);
- float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ float ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), targetValue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(90.0f);
- float relativeValue(targetValue - startValue);
+ float targetValue(90.0f);
+ float relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
- float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ float ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- float current( actor.GetCurrentProperty< float >( index ) );
- DALI_TEST_CHECK( current > ninetyFivePercentProgress );
+ float current(actor.GetCurrentProperty<float>(index));
+ DALI_TEST_CHECK(current > ninetyFivePercentProgress);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(30.0f);
- float relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ float targetValue(30.0f);
+ float relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(30.0f);
- float relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ float targetValue(30.0f);
+ float relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(1);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(1);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(50);
- int relativeValue(targetValue - startValue);
+ int targetValue(50);
+ int relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue);
- int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
+ int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue * 0.95f + 0.5f));
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), targetValue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(1);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(1);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(90);
- int relativeValue(targetValue - startValue);
+ int targetValue(90);
+ int relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
- int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
+ int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue * 0.95f + 0.5f));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- int current( actor.GetCurrentProperty< int >( index ) );
- DALI_TEST_CHECK( current > ninetyFivePercentProgress );
+ int current(actor.GetCurrentProperty<int>(index));
+ DALI_TEST_CHECK(current > ninetyFivePercentProgress);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(10);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(10);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(30);
- int relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ int targetValue(30);
+ int relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), static_cast<int>(startValue + (relativeValue * 0.5f) + 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(10);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(10);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(30);
- int relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ int targetValue(30);
+ int relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), static_cast<int>(startValue + (relativeValue * 0.5f) + 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a quaternion property
- const Quaternion startValue( Degree( 90 ), Vector3::XAXIS );
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ const Quaternion startValue(Degree(90), Vector3::XAXIS);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty< Quaternion >(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< Quaternion >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<Quaternion>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Quaternion>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
- Animation animation = Animation::New(durationSeconds);
- const Quaternion relativeValue( Degree( 90 ), Vector3::ZAXIS );
- const Quaternion finalValue( startValue * relativeValue );
+ float durationSeconds(2.0f);
+ Animation animation = Animation::New(durationSeconds);
+ const Quaternion relativeValue(Degree(90), Vector3::ZAXIS);
+ const Quaternion finalValue(startValue * relativeValue);
animation.AnimateBy(Property(actor, index), relativeValue);
- DALI_TEST_CHECK( actor.GetProperty< Quaternion >(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< Quaternion >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<Quaternion>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Quaternion>(index) == startValue);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_CHECK( actor.GetProperty< Quaternion >(index) == finalValue );
+ DALI_TEST_CHECK(actor.GetProperty<Quaternion>(index) == finalValue);
application.SendNotification();
- application.Render( 2000 ); // animation complete
+ application.Render(2000); // animation complete
- DALI_TEST_CHECK( actor.GetProperty< Quaternion >(index) == finalValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< Quaternion >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetProperty<Quaternion>(index) == finalValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Quaternion>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(60.0f, 60.0f);
- Vector2 relativeValue(targetValue - startValue);
+ Vector2 targetValue(60.0f, 60.0f);
+ Vector2 relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue);
- Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector2 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), targetValue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(100.0f, 100.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(100.0f, 100.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(20.0f, 20.0f);
- Vector2 relativeValue(targetValue - startValue);
+ Vector2 targetValue(20.0f, 20.0f);
+ Vector2 relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
- Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector2 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector2 current( actor.GetCurrentProperty< Vector2 >( index ) );
- DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
+ Vector2 current(actor.GetCurrentProperty<Vector2>(index));
+ DALI_TEST_CHECK(current.x < ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyFivePercentProgress.y);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(30.0f, 30.0f);
- Vector2 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector2 targetValue(30.0f, 30.0f);
+ Vector2 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(5.0f, 5.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(5.0f, 5.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(10.0f, 10.0f);
- Vector2 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector2 targetValue(10.0f, 10.0f);
+ Vector2 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(60.0f, 60.0f, 60.0f);
- Vector3 relativeValue(targetValue - startValue);
+ Vector3 targetValue(60.0f, 60.0f, 60.0f);
+ Vector3 relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue);
- Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector3 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), targetValue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(100.0f, 100.0f, 100.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(100.0f, 100.0f, 100.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(20.0f, 20.0f, 20.0f);
- Vector3 relativeValue(targetValue - startValue);
+ Vector3 targetValue(20.0f, 20.0f, 20.0f);
+ Vector3 relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
- Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector3 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( index ));
- DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
- DALI_TEST_CHECK( current.z < ninetyFivePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(index));
+ DALI_TEST_CHECK(current.x < ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyFivePercentProgress.y);
+ DALI_TEST_CHECK(current.z < ninetyFivePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(30.0f, 30.0f, 30.0f);
- Vector3 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector3 targetValue(30.0f, 30.0f, 30.0f);
+ Vector3 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(5.0f, 5.0f, 5.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(5.0f, 5.0f, 5.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(10.0f, 10.0f, 10.0f);
- Vector3 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector3 targetValue(10.0f, 10.0f, 10.0f);
+ Vector3 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(60.0f, 60.0f, 60.0f, 60.0f);
- Vector4 relativeValue(targetValue - startValue);
+ Vector4 targetValue(60.0f, 60.0f, 60.0f, 60.0f);
+ Vector4 relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue);
- Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector4 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), targetValue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(100.0f, 100.0f, 100.0f, 100.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(100.0f, 100.0f, 100.0f, 100.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(20.0f, 20.0f, 20.0f, 20.0f);
- Vector4 relativeValue(targetValue - startValue);
+ Vector4 targetValue(20.0f, 20.0f, 20.0f, 20.0f);
+ Vector4 relativeValue(targetValue - startValue);
animation.AnimateBy(Property(actor, index), relativeValue, AlphaFunction::EASE_OUT);
- Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector4 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector4 current( actor.GetCurrentProperty< Vector4 >( index ) );
- DALI_TEST_CHECK( current.x < ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyFivePercentProgress.y );
- DALI_TEST_CHECK( current.z < ninetyFivePercentProgress.z );
- DALI_TEST_CHECK( current.w < ninetyFivePercentProgress.w );
+ Vector4 current(actor.GetCurrentProperty<Vector4>(index));
+ DALI_TEST_CHECK(current.x < ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyFivePercentProgress.y);
+ DALI_TEST_CHECK(current.z < ninetyFivePercentProgress.z);
+ DALI_TEST_CHECK(current.w < ninetyFivePercentProgress.w);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
- Vector4 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
+ Vector4 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(5.0f, 5.0f, 5.0f, 5.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(5.0f, 5.0f, 5.0f, 5.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(10.0f, 10.0f, 10.0f, 10.0f);
- Vector4 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector4 targetValue(10.0f, 10.0f, 10.0f, 10.0f);
+ Vector4 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, index),
relativeValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 startPosition(10.0f, 10.0f, 10.0f);
- actor.SetProperty( Actor::Property::POSITION, startPosition );
+ actor.SetProperty(Actor::Property::POSITION, startPosition);
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), startPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), startPosition, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(20.0f, 20.0f, 20.0f);
- Vector3 relativePosition(targetPosition - startPosition);
+ Vector3 targetPosition(20.0f, 20.0f, 20.0f);
+ Vector3 relativePosition(targetPosition - startPosition);
animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition);
- Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
+ Vector3 ninetyFivePercentProgress(startPosition + relativePosition * 0.95f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(200.0f, 300.0f, 400.0f);
- Vector3 relativePosition(targetPosition - Vector3::ZERO);
- animation.AnimateBy( Property( actor, Actor::Property::POSITION_X ), relativePosition.x );
- animation.AnimateBy( Property( actor, Actor::Property::POSITION_Y ), relativePosition.y );
- animation.AnimateBy( Property( actor, Actor::Property::POSITION_Z ), relativePosition.z );
+ Vector3 targetPosition(200.0f, 300.0f, 400.0f);
+ Vector3 relativePosition(targetPosition - Vector3::ZERO);
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION_X), relativePosition.x);
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION_Y), relativePosition.y);
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION_Z), relativePosition.z);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), targetPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Y ), targetPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Z ), targetPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 startPosition(10.0f, 10.0f, 10.0f);
- actor.SetProperty( Actor::Property::POSITION, startPosition );
+ actor.SetProperty(Actor::Property::POSITION, startPosition);
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), startPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), startPosition, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(20.0f, 20.0f, 20.0f);
- Vector3 relativePosition(targetPosition - startPosition);
+ Vector3 targetPosition(20.0f, 20.0f, 20.0f);
+ Vector3 relativePosition(targetPosition - startPosition);
animation.AnimateBy(Property(actor, Actor::Property::POSITION), relativePosition, AlphaFunction::EASE_OUT);
- Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
+ Vector3 ninetyFivePercentProgress(startPosition + relativePosition * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
- DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
- DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
+ DALI_TEST_CHECK(current.x > ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y > ninetyFivePercentProgress.y);
+ DALI_TEST_CHECK(current.z > ninetyFivePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 startPosition(10.0f, 10.0f, 10.0f);
- actor.SetProperty( Actor::Property::POSITION, startPosition );
+ actor.SetProperty(Actor::Property::POSITION, startPosition);
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), startPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), startPosition, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(20.0f, 20.0f, 20.0f);
- Vector3 relativePosition(targetPosition - startPosition);
- float delay = 0.5f;
+ Vector3 targetPosition(20.0f, 20.0f, 20.0f);
+ Vector3 relativePosition(targetPosition - startPosition);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, Actor::Property::POSITION),
relativePosition,
TimePeriod(delay, durationSeconds - delay));
- Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
+ Vector3 ninetyFivePercentProgress(startPosition + relativePosition * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), startPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), startPosition, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Vector3 startPosition(10.0f, 10.0f, 10.0f);
- actor.SetProperty( Actor::Property::POSITION, startPosition );
+ actor.SetProperty(Actor::Property::POSITION, startPosition);
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), startPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), startPosition, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(20.0f, 20.0f, 20.0f);
- Vector3 relativePosition(targetPosition - startPosition);
- float delay = 0.5f;
+ Vector3 targetPosition(20.0f, 20.0f, 20.0f);
+ Vector3 relativePosition(targetPosition - startPosition);
+ float delay = 0.5f;
animation.AnimateBy(Property(actor, Actor::Property::POSITION),
relativePosition,
AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
- Vector3 ninetyFivePercentProgress(startPosition + relativePosition*0.95f);
+ Vector3 ninetyFivePercentProgress(startPosition + relativePosition * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), startPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), startPosition, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree relativeRotationDegrees(360.0f);
- Radian relativeRotationRadians(relativeRotationDegrees);
- animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ) );
+ Degree relativeRotationDegrees(360.0f);
+ Radian relativeRotationRadians(relativeRotationDegrees);
+ animation.AnimateBy(Property(actor, Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS));
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians, Vector3::YAXIS), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS), TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
tet_printf("Testing that rotation angle > 360 performs full rotations\n");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::ZAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree relativeRotationDegrees(710.0f);
- Radian relativeRotationRadians(relativeRotationDegrees);
+ Degree relativeRotationDegrees(710.0f);
+ Radian relativeRotationRadians(relativeRotationDegrees);
- animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), AngleAxis( relativeRotationRadians, Vector3::ZAXIS ) );
+ animation.AnimateBy(Property(actor, Actor::Property::ORIENTATION), AngleAxis(relativeRotationRadians, Vector3::ZAXIS));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliAnimationAnimateByActorOrientationP3(void)
{
TestApplication application;
tet_printf("Testing that rotation angle > 360 performs partial rotations when cast to Quaternion\n");
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::ZAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::ZAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree relativeRotationDegrees(730.0f);
- Radian relativeRotationRadians(relativeRotationDegrees);
+ Degree relativeRotationDegrees(730.0f);
+ Radian relativeRotationRadians(relativeRotationDegrees);
- Radian actualRotationRadians( Degree(10.0f) );
+ Radian actualRotationRadians(Degree(10.0f));
- animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::ZAXIS ) );
+ animation.AnimateBy(Property(actor, Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::ZAXIS));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(actualRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(actualRotationRadians * 0.25f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(actualRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(actualRotationRadians * 0.5f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(actualRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(actualRotationRadians * 0.75f, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(actualRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(actualRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::ZAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliAnimationAnimateByActorOrientationAlphaFunctionP(void)
{
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree relativeRotationDegrees(360.0f);
- Radian relativeRotationRadians(relativeRotationDegrees);
- animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ), AlphaFunction::EASE_IN );
+ Degree relativeRotationDegrees(360.0f);
+ Radian relativeRotationRadians(relativeRotationDegrees);
+ animation.AnimateBy(Property(actor, Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS), AlphaFunction::EASE_IN);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.25f * 0.25f * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.5f * 0.5f * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * 0.75f * 0.75f * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree relativeRotationDegrees(360.0f);
- Radian relativeRotationRadians(relativeRotationDegrees);
- float delay = 0.3f;
- animation.AnimateBy( Property( actor, Actor::Property::ORIENTATION ), Quaternion( relativeRotationRadians, Vector3::YAXIS ),
- AlphaFunction::EASE_IN, TimePeriod( delay, durationSeconds - delay ) );
+ Degree relativeRotationDegrees(360.0f);
+ Radian relativeRotationRadians(relativeRotationDegrees);
+ float delay = 0.3f;
+ animation.AnimateBy(Property(actor, Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * progress * progress * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * progress * progress * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians * progress * progress * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(relativeRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetScale(2.0f, 2.0f, 2.0f);
- Vector3 relativeScale(targetScale - Vector3::ONE);
- animation.AnimateBy( Property( actor, Actor::Property::SCALE ), Vector3( relativeScale.x, relativeScale.y, relativeScale.z ) );
+ Vector3 targetScale(2.0f, 2.0f, 2.0f);
+ Vector3 relativeScale(targetScale - Vector3::ONE);
+ animation.AnimateBy(Property(actor, Actor::Property::SCALE), Vector3(relativeScale.x, relativeScale.y, relativeScale.z));
- Vector3 ninetyNinePercentProgress(Vector3::ONE + relativeScale*0.99f);
+ Vector3 ninetyNinePercentProgress(Vector3::ONE + relativeScale * 0.99f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), ninetyNinePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), ninetyNinePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SCALE,Vector3::ONE);
+ actor.SetProperty(Actor::Property::SCALE, Vector3::ONE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::EASE_IN );
+ animation.AnimateBy(Property(actor, Actor::Property::SCALE), relativeScale, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The scale should have grown less, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
- DALI_TEST_CHECK( current.x > 1.0f );
- DALI_TEST_CHECK( current.y > 1.0f );
- DALI_TEST_CHECK( current.z > 1.0f );
- DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
- DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
+ DALI_TEST_CHECK(current.x > 1.0f);
+ DALI_TEST_CHECK(current.y > 1.0f);
+ DALI_TEST_CHECK(current.z > 1.0f);
+ DALI_TEST_CHECK(current.x < ninetyNinePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyNinePercentProgress.y);
+ DALI_TEST_CHECK(current.z < ninetyNinePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SCALE,Vector3::ONE);
+ actor.SetProperty(Actor::Property::SCALE, Vector3::ONE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Repeat with a delay
float delay = 0.5f;
- animation = Animation::New(durationSeconds);
- animation.AnimateBy( Property( actor, Actor::Property::SCALE ), relativeScale, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
+ animation = Animation::New(durationSeconds);
+ animation.AnimateBy(Property(actor, Actor::Property::SCALE), relativeScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetScale(2.0f, 3.0f, 4.0f);
- Vector3 relativeScale(targetScale - Vector3::ONE);
- animation.AnimateBy( Property( actor, Actor::Property::SCALE_X ), relativeScale.x );
- animation.AnimateBy( Property( actor, Actor::Property::SCALE_Y ), relativeScale.y );
- animation.AnimateBy( Property( actor, Actor::Property::SCALE_Z ), relativeScale.z );
+ Vector3 targetScale(2.0f, 3.0f, 4.0f);
+ Vector3 relativeScale(targetScale - Vector3::ONE);
+ animation.AnimateBy(Property(actor, Actor::Property::SCALE_X), relativeScale.x);
+ animation.AnimateBy(Property(actor, Actor::Property::SCALE_Y), relativeScale.y);
+ animation.AnimateBy(Property(actor, Actor::Property::SCALE_Z), relativeScale.z);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_X ), targetScale.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_Y ), targetScale.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_Z ), targetScale.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_X), targetScale.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Y), targetScale.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Z), targetScale.z, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetColor( 0.5f, 0.75f, 0.8f, 0.1f );
- Vector4 relativeColor( targetColor - Color::WHITE );
- animation.AnimateBy( Property( actor, Actor::Property::COLOR ), relativeColor );
+ Vector4 targetColor(0.5f, 0.75f, 0.8f, 0.1f);
+ Vector4 relativeColor(targetColor - Color::WHITE);
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR), relativeColor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_RED ), targetColor.r, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), targetColor.g, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), targetColor.b, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), targetColor.a, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColor.r, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetColor.g, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), targetColor.b, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetColor.a, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetColor( 0.5f, 0.75f, 0.8f, 0.1f );
- Vector4 relativeColor( targetColor - Color::WHITE );
- animation.AnimateBy( Property( actor, Actor::Property::COLOR_RED ), relativeColor.r );
- animation.AnimateBy( Property( actor, Actor::Property::COLOR_GREEN ), relativeColor.g );
- animation.AnimateBy( Property( actor, Actor::Property::COLOR_BLUE ), relativeColor.b );
- animation.AnimateBy( Property( actor, Actor::Property::COLOR_ALPHA ), relativeColor.a );
+ Vector4 targetColor(0.5f, 0.75f, 0.8f, 0.1f);
+ Vector4 relativeColor(targetColor - Color::WHITE);
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR_RED), relativeColor.r);
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR_GREEN), relativeColor.g);
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR_BLUE), relativeColor.b);
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR_ALPHA), relativeColor.a);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_RED ), targetColor.r, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), targetColor.g, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), targetColor.b, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), targetColor.a, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColor.r, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetColor.g, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), targetColor.b, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetColor.a, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetSize( 100.0f, 200.0f, 300.0f );
- Vector3 relativeSize( targetSize - Vector3::ZERO );
- animation.AnimateBy( Property( actor, Actor::Property::SIZE ), relativeSize );
+ Vector3 targetSize(100.0f, 200.0f, 300.0f);
+ Vector3 relativeSize(targetSize - Vector3::ZERO);
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE), relativeSize);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), targetSize.width, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), targetSize.height, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), targetSize.depth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSize.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSize.height, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSize.depth, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetSize( 100.0f, 200.0f, 300.0f );
- Vector3 relativeSize( targetSize - Vector3::ZERO );
- animation.AnimateBy( Property( actor, Actor::Property::SIZE_WIDTH ), relativeSize.width );
- animation.AnimateBy( Property( actor, Actor::Property::SIZE_HEIGHT ), relativeSize.height );
- animation.AnimateBy( Property( actor, Actor::Property::SIZE_DEPTH ), relativeSize.depth );
+ Vector3 targetSize(100.0f, 200.0f, 300.0f);
+ Vector3 relativeSize(targetSize - Vector3::ZERO);
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE_WIDTH), relativeSize.width);
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE_HEIGHT), relativeSize.height);
+ animation.AnimateBy(Property(actor, Actor::Property::SIZE_DEPTH), relativeSize.depth);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), targetSize.width, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), targetSize.height, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), targetSize.depth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSize.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSize.height, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSize.depth, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
- actor.SetProperty( Actor::Property::VISIBLE, false );
+ actor.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- bool targetVisibility( true );
- bool relativeVisibility( targetVisibility );
- animation.AnimateBy( Property( actor, Actor::Property::VISIBLE ), relativeVisibility );
+ bool targetVisibility(true);
+ bool relativeVisibility(targetVisibility);
+ animation.AnimateBy(Property(actor, Actor::Property::VISIBLE), relativeVisibility);
- DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< bool >( Actor::Property::VISIBLE ), targetVisibility, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION ); // Not changed yet
+ DALI_TEST_EQUALS(actor.GetProperty<bool>(Actor::Property::VISIBLE), targetVisibility, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION); // Not changed yet
application.SendNotification();
- application.Render( 1000 ); // 1 second progress
+ application.Render(1000); // 1 second progress
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- const bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ const bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
- Animation animation = Animation::New(durationSeconds);
- const bool targetValue( !startValue );
+ float durationSeconds(2.0f);
+ Animation animation = Animation::New(durationSeconds);
+ const bool targetValue(!startValue);
animation.AnimateTo(Property(actor, index), targetValue);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
// Repeat with target value "false"
animation = Animation::New(durationSeconds);
- const bool finalValue( !targetValue );
+ const bool finalValue(!targetValue);
animation.AnimateTo(Property(actor, index), finalValue);
// Start the animation
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- const bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ const bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
- Animation animation = Animation::New(durationSeconds);
- const bool targetValue( !startValue );
+ float durationSeconds(2.0f);
+ Animation animation = Animation::New(durationSeconds);
+ const bool targetValue(!startValue);
animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
// Repeat with target value "false"
animation = Animation::New(durationSeconds);
- const bool finalValue( !targetValue );
+ const bool finalValue(!targetValue);
animation.AnimateTo(Property(actor, index), finalValue, AlphaFunction::EASE_OUT);
// Start the animation
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == targetValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == targetValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- bool finalValue( !startValue );
- float animatorDurationSeconds(durationSeconds * 0.5f);
- animation.AnimateTo( Property(actor, index),
- finalValue,
- TimePeriod( animatorDurationSeconds ) );
+ bool finalValue(!startValue);
+ float animatorDurationSeconds(durationSeconds * 0.5f);
+ animation.AnimateTo(Property(actor, index),
+ finalValue,
+ TimePeriod(animatorDurationSeconds));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 950.0f) /* 95% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 50.0f) + 1u /*just beyond the animator duration*/);
// We didn't expect the animation to finish yet...
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// ...however we should have reached the final value
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 1000.0f) /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a boolean property
- bool startValue(false);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ bool startValue(false);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_CHECK( actor.GetProperty<bool>(index) == startValue );
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetProperty<bool>(index) == startValue);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- bool finalValue( !startValue );
- float animatorDurationSeconds(durationSeconds * 0.5f);
- animation.AnimateTo( Property(actor, index),
- finalValue,
- AlphaFunction::LINEAR,
- TimePeriod( animatorDurationSeconds ) );
+ bool finalValue(!startValue);
+ float animatorDurationSeconds(durationSeconds * 0.5f);
+ animation.AnimateTo(Property(actor, index),
+ finalValue,
+ AlphaFunction::LINEAR,
+ TimePeriod(animatorDurationSeconds));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*950.0f)/* 95% animator progress */);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 950.0f) /* 95% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == startValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == startValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*50.0f) + 1u/*just beyond the animator duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 50.0f) + 1u /*just beyond the animator duration*/);
// We didn't expect the animation to finish yet...
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// ...however we should have reached the final value
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.SendNotification();
- application.Render(static_cast<unsigned int>(animatorDurationSeconds*1000.0f)/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(animatorDurationSeconds * 1000.0f) /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
application.Render(0);
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( index ) == finalValue );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(index) == finalValue);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(50.0f);
- float relativeValue(targetValue - startValue);
+ float targetValue(50.0f);
+ float relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, "testProperty"), targetValue);
- float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ float ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(90.0f);
- float relativeValue(targetValue - startValue);
+ float targetValue(90.0f);
+ float relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
- float ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ float ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- float current( actor.GetCurrentProperty< float >( index ) );
- DALI_TEST_CHECK( current > ninetyFivePercentProgress );
+ float current(actor.GetCurrentProperty<float>(index));
+ DALI_TEST_CHECK(current > ninetyFivePercentProgress);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(30.0f);
- float relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ float targetValue(30.0f);
+ float relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetValue(30.0f);
- float relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ float targetValue(30.0f);
+ float relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(10);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(10);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(50);
- int relativeValue(targetValue - startValue);
+ int targetValue(50);
+ int relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, "testProperty"), targetValue);
- int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
+ int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue * 0.95f + 0.5f));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(10);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(10);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(90);
- int relativeValue(targetValue - startValue);
+ int targetValue(90);
+ int relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
- int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue*0.95f + 0.5f));
+ int ninetyFivePercentProgress(static_cast<int>(startValue + relativeValue * 0.95f + 0.5f));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- int current( actor.GetCurrentProperty< int >( index ) );
- DALI_TEST_CHECK( current > ninetyFivePercentProgress );
+ int current(actor.GetCurrentProperty<int>(index));
+ DALI_TEST_CHECK(current > ninetyFivePercentProgress);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(10);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(10);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(30);
- int relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ int targetValue(30);
+ int relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), static_cast<int>(startValue + (relativeValue * 0.5f) + 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(10);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(10);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- int targetValue(30);
- int relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ int targetValue(30);
+ int relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), static_cast<int>(startValue+(relativeValue*0.5f)+0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), static_cast<int>(startValue + (relativeValue * 0.5f) + 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(-50.0f, -50.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(-50.0f, -50.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(50.0f, 50.0f);
- Vector2 relativeValue(targetValue - startValue);
+ Vector2 targetValue(50.0f, 50.0f);
+ Vector2 relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue);
- Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector2 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(1000.0f, 1000.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(1000.0f, 1000.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(9000.0f, 9000.0f);
- Vector2 relativeValue(targetValue - startValue);
+ Vector2 targetValue(9000.0f, 9000.0f);
+ Vector2 relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, "testProperty"), targetValue, AlphaFunction::EASE_OUT);
- Vector2 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector2 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector2 current( actor.GetCurrentProperty< Vector2 >( index ) );
- DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
+ Vector2 current(actor.GetCurrentProperty<Vector2>(index));
+ DALI_TEST_CHECK(current.x > ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y > ninetyFivePercentProgress.y);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(-10.0f, 20.0f);
- Vector2 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector2 targetValue(-10.0f, 20.0f);
+ Vector2 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector2 property
- Vector2 startValue(10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector2 startValue(10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector2 targetValue(30.0f, 30.0f);
- Vector2 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector2 targetValue(30.0f, 30.0f);
+ Vector2 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet, but cached value should be the final one
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty<Vector2>( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector2>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(-50.0f, -50.0f, -50.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(-50.0f, -50.0f, -50.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>( index ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(50.0f, 50.0f, 50.0f);
- Vector3 relativeValue(targetValue - startValue);
+ Vector3 targetValue(50.0f, 50.0f, 50.0f);
+ Vector3 relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue);
- Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector3 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(1000.0f, 1000.0f, 1000.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(1000.0f, 1000.0f, 1000.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(9000.0f, 9000.0f, 9000.0f);
- Vector3 relativeValue(targetValue - startValue);
+ Vector3 targetValue(9000.0f, 9000.0f, 9000.0f);
+ Vector3 relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
- Vector3 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector3 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector3 current( actor.GetCurrentProperty< Vector3 >( index ) );
- DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
- DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(index));
+ DALI_TEST_CHECK(current.x > ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y > ninetyFivePercentProgress.y);
+ DALI_TEST_CHECK(current.z > ninetyFivePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(-10.0f, 20.0f, 100.0f);
- Vector3 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector3 targetValue(-10.0f, 20.0f, 100.0f);
+ Vector3 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(30.0f, 30.0f, 30.0f);
- Vector3 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector3 targetValue(30.0f, 30.0f, 30.0f);
+ Vector3 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, "testProperty"),
targetValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector3 property
- Vector3 startValue(10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector3 startValue(10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetValue(30.0f, 30.0f, 10.0f);
- Vector3 relativeValue(targetValue - startValue);
- float delay = 0.5f;
- animation.AnimateTo(Property(actor, "testProperty", 0),
+ Vector3 targetValue(30.0f, 30.0f, 10.0f);
+ Vector3 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
+ animation.AnimateTo(Property(actor, "testProperty", 0),
30.0f,
AlphaFunction::LINEAR,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(-50.0f, -40.0f, -30.0f, -20.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(-50.0f, -40.0f, -30.0f, -20.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(50.0f, 50.0f, 50.0f, 50.0f);
- Vector4 relativeValue(targetValue - startValue);
+ Vector4 targetValue(50.0f, 50.0f, 50.0f, 50.0f);
+ Vector4 relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue);
- Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector4 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), ninetyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), ninetyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(1000.0f, 1000.0f, 1000.0f, 1000.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(1000.0f, 1000.0f, 1000.0f, 1000.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(9000.0f, 9000.0f, 9000.0f, 9000.0f);
- Vector4 relativeValue(targetValue - startValue);
+ Vector4 targetValue(9000.0f, 9000.0f, 9000.0f, 9000.0f);
+ Vector4 relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index), targetValue, AlphaFunction::EASE_OUT);
- Vector4 ninetyFivePercentProgress(startValue + relativeValue*0.95f);
+ Vector4 ninetyFivePercentProgress(startValue + relativeValue * 0.95f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*950.0f)/* 95% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 950.0f) /* 95% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved more, than with a linear alpha function
- Vector4 current( actor.GetCurrentProperty< Vector4 >( index ) );
- DALI_TEST_CHECK( current.x > ninetyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y > ninetyFivePercentProgress.y );
- DALI_TEST_CHECK( current.z > ninetyFivePercentProgress.z );
- DALI_TEST_CHECK( current.w > ninetyFivePercentProgress.w );
+ Vector4 current(actor.GetCurrentProperty<Vector4>(index));
+ DALI_TEST_CHECK(current.x > ninetyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y > ninetyFivePercentProgress.y);
+ DALI_TEST_CHECK(current.z > ninetyFivePercentProgress.z);
+ DALI_TEST_CHECK(current.w > ninetyFivePercentProgress.w);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*50.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, VECTOR4_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, VECTOR4_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(-10.0f, 20.0f, 100.0f, 100.0f);
- Vector4 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector4 targetValue(-10.0f, 20.0f, 100.0f, 100.0f);
+ Vector4 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, VECTOR4_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, VECTOR4_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue+(relativeValue*0.5f), VECTOR4_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue + (relativeValue * 0.5f), VECTOR4_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, VECTOR4_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, VECTOR4_EPSILON, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a Vector4 property
- Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ Vector4 startValue(10.0f, 10.0f, 10.0f, 10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
- Vector4 relativeValue(targetValue - startValue);
- float delay = 0.5f;
+ Vector4 targetValue(30.0f, 30.0f, 30.0f, 30.0f);
+ Vector4 relativeValue(targetValue - startValue);
+ float delay = 0.5f;
animation.AnimateTo(Property(actor, index),
targetValue,
AlphaFunction::LINEAR,
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(index), targetValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_LEFT, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_LEFT, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetParentOrigin(ParentOrigin::BOTTOM_RIGHT);
+ Vector3 targetParentOrigin(ParentOrigin::BOTTOM_RIGHT);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN), targetParentOrigin );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::PARENT_ORIGIN), targetParentOrigin);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).x, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_X), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).x, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_X), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetX(1.0f);
+ float targetX(1.0f);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_X), targetX );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::PARENT_ORIGIN_X), targetX);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).y, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Y), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).y, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Y), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetY(1.0f);
+ float targetY(1.0f);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Y), targetY );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::PARENT_ORIGIN_Y), targetY);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.5f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ).z, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN).z, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::PARENT_ORIGIN_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetZ(1.0f);
+ float targetZ(1.0f);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::PARENT_ORIGIN_Z), targetZ );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::PARENT_ORIGIN_Z), targetZ);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), AnchorPoint::CENTER, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), AnchorPoint::CENTER, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetAnchorPoint(AnchorPoint::TOP_LEFT);
+ Vector3 targetAnchorPoint(AnchorPoint::TOP_LEFT);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT), targetAnchorPoint);
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::ANCHOR_POINT), targetAnchorPoint);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.5f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).x, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_X), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).x, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_X), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetX(1.0f);
+ float targetX(1.0f);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_X), targetX );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::ANCHOR_POINT_X), targetX);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.5f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).y, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Y), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).y, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Y), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetY(0.0f);
+ float targetY(0.0f);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Y), targetY );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::ANCHOR_POINT_Y), targetY);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.5f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ).z, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT).z, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::ANCHOR_POINT_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetZ(100.0f);
+ float targetZ(100.0f);
DALI_TEST_ASSERTION(
- {
- animation.AnimateTo( Property(actor, Actor::Property::ANCHOR_POINT_Z), targetZ );
- }, "Property is not animatable" );
+ {
+ animation.AnimateTo(Property(actor, Actor::Property::ANCHOR_POINT_Z), targetZ);
+ },
+ "Property is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetSize(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize );
+ Vector3 targetSize(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSize);
Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), 0.0f, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), targetSize.width, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), targetSize.height, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), targetSize.depth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSize.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSize.height, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSize.depth, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), ninetyNinePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), ninetyNinePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ZERO);
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ZERO);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::EASE_IN);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The size should have travelled less, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
- DALI_TEST_CHECK( current.x > 0.0f );
- DALI_TEST_CHECK( current.y > 0.0f );
- DALI_TEST_CHECK( current.z > 0.0f );
- DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
- DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
+ DALI_TEST_CHECK(current.x > 0.0f);
+ DALI_TEST_CHECK(current.y > 0.0f);
+ DALI_TEST_CHECK(current.z > 0.0f);
+ DALI_TEST_CHECK(current.x < ninetyNinePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyNinePercentProgress.y);
+ DALI_TEST_CHECK(current.z < ninetyNinePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ZERO);
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ZERO);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Repeat with a delay
float delay = 0.5f;
- animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
+ animation = Animation::New(durationSeconds);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSize, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetWidth(10.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE_WIDTH), targetWidth );
+ float targetWidth(10.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_WIDTH), targetWidth);
- float fiftyPercentProgress(startValue + (targetWidth - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetWidth - startValue) * 0.5f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), startValue, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3( targetWidth, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_WIDTH ), targetWidth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3(targetWidth, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetWidth, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).width, targetWidth, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetWidth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).width, targetWidth, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetWidth, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetHeight(-10.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE_HEIGHT), targetHeight );
+ float targetHeight(-10.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_HEIGHT), targetHeight);
- float fiftyPercentProgress(startValue + (targetHeight - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetHeight - startValue) * 0.5f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), startValue, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3( 0.0f, targetHeight, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_HEIGHT ), targetHeight, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3(0.0f, targetHeight, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetHeight, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).height, targetHeight, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetHeight, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).height, targetHeight, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetHeight, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).depth, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).depth, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetDepth(-10.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SIZE_DEPTH), targetDepth );
+ float targetDepth(-10.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_DEPTH), targetDepth);
- float fiftyPercentProgress(startValue + (targetDepth - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetDepth - startValue) * 0.5f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), startValue, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SIZE ), Vector3( 0.0f, 0.0f, targetDepth ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SIZE_DEPTH ), targetDepth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3(0.0f, 0.0f, targetDepth), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetDepth, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).depth, fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).depth, fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).depth, targetDepth, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetDepth, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).depth, targetDepth, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetDepth, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetSize(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::SIZE ), targetSize );
+ Vector3 targetSize(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE), targetSize);
Vector3 ninetyNinePercentProgress(targetSize * 0.99f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), ninetyNinePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), ninetyNinePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), targetSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), targetSize, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ZERO);
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ZERO);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::EASE_IN );
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::EASE_IN );
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_WIDTH), targetSize.x, AlphaFunction::EASE_IN);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_HEIGHT), targetSize.y, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The size should have travelled less, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ));
- DALI_TEST_CHECK( current.x > 0.0f );
- DALI_TEST_CHECK( current.y > 0.0f );
- DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE));
+ DALI_TEST_CHECK(current.x > 0.0f);
+ DALI_TEST_CHECK(current.y > 0.0f);
+ DALI_TEST_CHECK(current.x < ninetyNinePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyNinePercentProgress.y);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).x, targetSize.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).y, targetSize.y, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).x, targetSize.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).y, targetSize.y, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ZERO);
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ZERO);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
// Repeat with a delay
float delay = 0.5f;
- animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_WIDTH ), targetSize.x, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
- animation.AnimateTo( Property( actor, Actor::Property::SIZE_HEIGHT ), targetSize.y, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
+ animation = Animation::New(durationSeconds);
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_WIDTH), targetSize.x, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
+ animation.AnimateTo(Property(actor, Actor::Property::SIZE_HEIGHT), targetSize.y, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ZERO, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).x, targetSize.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ).y, targetSize.y, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).x, targetSize.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SIZE).y, targetSize.y, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(200.0f, 200.0f, 200.0f);
+ Vector3 targetPosition(200.0f, 200.0f, 200.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Y ), 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Z ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), 0.0f, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), targetPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Y ), targetPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Z ), targetPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 750.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), seventyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), seventyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetX(1.0f);
- animation.AnimateTo( Property(actor, Actor::Property::POSITION_X), targetX );
+ float targetX(1.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), targetX);
- float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetX - startValue) * 0.5f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( targetX, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), targetX, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(targetX, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetX, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x, targetX, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetX, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x, targetX, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetX, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetY(10.0f);
- animation.AnimateTo( Property(actor, Actor::Property::POSITION_Y), targetY );
+ float targetY(10.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_Y), targetY);
- float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetY - startValue) * 0.5f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Y ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, targetY, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Y ), targetY, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, targetY, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetY, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).y, targetY, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetY, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).y, targetY, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetY, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(0.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetZ(-5.0f);
- animation.AnimateTo( Property(actor, Actor::Property::POSITION_Z), targetZ );
+ float targetZ(-5.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_Z), targetZ);
- float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetZ - startValue) * 0.5f);
// Should return the initial properties before play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), startValue, TEST_LOCATION);
// Start the animation
animation.Play();
// Should return the target property after play
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, targetZ ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_Z ), targetZ, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, targetZ), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetZ, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).z, targetZ, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetZ, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).z, targetZ, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetZ, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(200.0f, 200.0f, 200.0f);
+ Vector3 targetPosition(200.0f, 200.0f, 200.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::EASE_IN);
Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*750.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 750.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The position should have moved less, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ));
- DALI_TEST_CHECK( current.x > Vector3::ZERO.x );
- DALI_TEST_CHECK( current.y > Vector3::ZERO.y );
- DALI_TEST_CHECK( current.z > Vector3::ZERO.z );
- DALI_TEST_CHECK( current.x < seventyFivePercentProgress.x );
- DALI_TEST_CHECK( current.y < seventyFivePercentProgress.y );
- DALI_TEST_CHECK( current.z < seventyFivePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
+ DALI_TEST_CHECK(current.x > Vector3::ZERO.x);
+ DALI_TEST_CHECK(current.y > Vector3::ZERO.y);
+ DALI_TEST_CHECK(current.z > Vector3::ZERO.z);
+ DALI_TEST_CHECK(current.x < seventyFivePercentProgress.x);
+ DALI_TEST_CHECK(current.y < seventyFivePercentProgress.y);
+ DALI_TEST_CHECK(current.z < seventyFivePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(200.0f, 200.0f, 200.0f);
- float delay = 0.5f;
- animation.AnimateTo( Property(actor, Actor::Property::POSITION),
- targetPosition,
- TimePeriod( delay, durationSeconds - delay ) );
+ Vector3 targetPosition(200.0f, 200.0f, 200.0f);
+ float delay = 0.5f;
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION),
+ targetPosition,
+ TimePeriod(delay, durationSeconds - delay));
Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f * 0.75) /* 7/8 animation progress, 3/4 animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), seventyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), seventyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f * 0.25) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetPosition(200.0f, 200.0f, 200.0f);
- float delay = 0.5f;
- animation.AnimateTo( Property(actor, Actor::Property::POSITION),
- targetPosition,
- AlphaFunction::LINEAR,
- TimePeriod( delay, durationSeconds - delay ) );
+ Vector3 targetPosition(200.0f, 200.0f, 200.0f);
+ float delay = 0.5f;
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION),
+ targetPosition,
+ AlphaFunction::LINEAR,
+ TimePeriod(delay, durationSeconds - delay));
Vector3 seventyFivePercentProgress(targetPosition * 0.75f);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.75)/* 7/8 animation progress, 3/4 animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f * 0.75) /* 7/8 animation progress, 3/4 animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), seventyFivePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), seventyFivePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f*0.25) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f * 0.25) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree targetRotationDegrees(90.0f);
- Radian targetRotationRadians(targetRotationDegrees);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationRadians, Vector3::YAXIS) );
+ Degree targetRotationDegrees(90.0f);
+ Radian targetRotationRadians(targetRotationDegrees);
+ animation.AnimateTo(Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationRadians, Vector3::YAXIS));
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
- Animation animation = Animation::New(durationSeconds);
- Degree targetRotationDegrees(90.0f);
- Radian targetRotationRadians(targetRotationDegrees);
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ Degree targetRotationDegrees(90.0f);
+ Radian targetRotationRadians(targetRotationDegrees);
Quaternion targetRotation(targetRotationRadians, Vector3::YAXIS);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), targetRotation );
+ animation.AnimateTo(Property(actor, Actor::Property::ORIENTATION), targetRotation);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(Radian(0.0f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Radian(0.0f), Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree targetRotationDegrees(90.0f);
- Radian targetRotationRadians(targetRotationDegrees);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN);
+ Degree targetRotationDegrees(90.0f);
+ Radian targetRotationRadians(targetRotationDegrees);
+ animation.AnimateTo(Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.25f*0.25f*0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.25f * 0.25f * 0.25f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.5f*0.5f*0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.5f * 0.5f * 0.5f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * 0.75f*0.75f*0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * 0.75f * 0.75f * 0.75f, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree targetRotationDegrees(90.0f);
- Radian targetRotationRadians(targetRotationDegrees);
- float delay(0.1f);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), TimePeriod(delay, durationSeconds - delay));
+ Degree targetRotationDegrees(90.0f);
+ Radian targetRotationRadians(targetRotationDegrees);
+ float delay(0.1f);
+ animation.AnimateTo(Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::ANGLE_0, Vector3::YAXIS ) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::ANGLE_0, Vector3::YAXIS));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Dali::ANGLE_0, Vector3::YAXIS ), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Dali::ANGLE_0, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Degree targetRotationDegrees(90.0f);
- Radian targetRotationRadians(targetRotationDegrees);
- float delay(0.1f);
- animation.AnimateTo( Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
+ Degree targetRotationDegrees(90.0f);
+ Radian targetRotationRadians(targetRotationDegrees);
+ float delay(0.1f);
+ animation.AnimateTo(Property(actor, Actor::Property::ORIENTATION), AngleAxis(targetRotationDegrees, Vector3::YAXIS), AlphaFunction::EASE_IN, TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
float progress = max(0.0f, 0.25f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * progress * progress * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.5f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * progress * progress * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
progress = max(0.0f, 0.75f - delay) / (1.0f - delay);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians * progress*progress*progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians * progress * progress * progress, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(targetRotationRadians, Vector3::YAXIS), ROTATION_EPSILON, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector3 targetScale(2.0f, 2.0f, 2.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale );
+ Vector3 targetScale(2.0f, 2.0f, 2.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE), targetScale);
- Vector3 ninetyNinePercentProgress(Vector3::ONE + (targetScale - Vector3::ONE)*0.99f);
+ Vector3 ninetyNinePercentProgress(Vector3::ONE + (targetScale - Vector3::ONE) * 0.99f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_X ), targetScale.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_Y ), targetScale.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_Z ), targetScale.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_X), targetScale.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Y), targetScale.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Z), targetScale.z, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), ninetyNinePercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), ninetyNinePercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SCALE,Vector3::ONE);
+ actor.SetProperty(Actor::Property::SCALE, Vector3::ONE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::EASE_IN);
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*990.0f)/* 99% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 990.0f) /* 99% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The scale should have grown less, than with a linear alpha function
- Vector3 current(actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ));
- DALI_TEST_CHECK( current.x > 1.0f );
- DALI_TEST_CHECK( current.y > 1.0f );
- DALI_TEST_CHECK( current.z > 1.0f );
- DALI_TEST_CHECK( current.x < ninetyNinePercentProgress.x );
- DALI_TEST_CHECK( current.y < ninetyNinePercentProgress.y );
- DALI_TEST_CHECK( current.z < ninetyNinePercentProgress.z );
+ Vector3 current(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE));
+ DALI_TEST_CHECK(current.x > 1.0f);
+ DALI_TEST_CHECK(current.y > 1.0f);
+ DALI_TEST_CHECK(current.z > 1.0f);
+ DALI_TEST_CHECK(current.x < ninetyNinePercentProgress.x);
+ DALI_TEST_CHECK(current.y < ninetyNinePercentProgress.y);
+ DALI_TEST_CHECK(current.z < ninetyNinePercentProgress.z);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::SCALE,Vector3::ONE);
+ actor.SetProperty(Actor::Property::SCALE, Vector3::ONE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
// Repeat with a delay
float delay = 0.5f;
- animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
+ animation = Animation::New(durationSeconds);
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE), targetScale, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), targetScale, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE), targetScale, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).x, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).x, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetX(10.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE_X), targetX );
+ float targetX(10.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE_X), targetX);
- float fiftyPercentProgress(startValue + (targetX - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetX - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), Vector3( targetX, startValue, startValue ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_X ), targetX, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), Vector3(targetX, startValue, startValue), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_X), targetX, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).x, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).x, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).x, targetX, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), targetX, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).x, targetX, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), targetX, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).y, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).y, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetY(1000.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE_Y), targetY );
+ float targetY(1000.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE_Y), targetY);
- float fiftyPercentProgress(startValue + (targetY - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetY - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), Vector3( startValue, targetY, startValue ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_Y ), targetY, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), Vector3(startValue, targetY, startValue), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Y), targetY, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).y, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).y, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).y, targetY, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), targetY, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).y, targetY, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), targetY, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).z, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).z, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetZ(-1000.0f);
- animation.AnimateTo( Property(actor, Actor::Property::SCALE_Z), targetZ );
+ float targetZ(-1000.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE_Z), targetZ);
- float fiftyPercentProgress(startValue + (targetZ - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetZ - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::SCALE ), Vector3( startValue, startValue, targetZ ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::SCALE_Z ), targetZ, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SCALE), Vector3(startValue, startValue, targetZ), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SCALE_Z), targetZ, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).z, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).z, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ).z, targetZ, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_X ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Y ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::SCALE_Z ), targetZ, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::SCALE).z, targetZ, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_X), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Y), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::SCALE_Z), targetZ, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- Vector4 targetColor(Color::RED);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor );
+ Vector4 targetColor(Color::RED);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR), targetColor);
Vector4 tenPercentProgress(Vector4(1.0f, 0.9f, 0.9f, 1.0f));
Vector4 twentyPercentProgress(Vector4(1.0f, 0.8f, 0.8f, 1.0f));
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_RED ), targetColor.r, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), targetColor.g, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), targetColor.b, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), targetColor.a, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::OPACITY ), targetColor.a, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColor.r, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetColor.g, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), targetColor.b, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetColor.a, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::OPACITY), targetColor.a, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 10% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), tenPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), tenPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 900.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::COLOR,Color::WHITE);
+ actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Repeat with a different (ease-in) alpha function
animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::EASE_IN);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::EASE_IN);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 10% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// The color should have changed less, than with a linear alpha function
- Vector4 current(actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ));
- DALI_TEST_CHECK( current.x == 1.0f ); // doesn't change
- DALI_TEST_CHECK( current.y < 1.0f );
- DALI_TEST_CHECK( current.y > tenPercentProgress.y );
- DALI_TEST_CHECK( current.z < 1.0f );
- DALI_TEST_CHECK( current.z > tenPercentProgress.z );
- DALI_TEST_CHECK( current.w == 1.0f ); // doesn't change
+ Vector4 current(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR));
+ DALI_TEST_CHECK(current.x == 1.0f); // doesn't change
+ DALI_TEST_CHECK(current.y < 1.0f);
+ DALI_TEST_CHECK(current.y > tenPercentProgress.y);
+ DALI_TEST_CHECK(current.z < 1.0f);
+ DALI_TEST_CHECK(current.z > tenPercentProgress.z);
+ DALI_TEST_CHECK(current.w == 1.0f); // doesn't change
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 900.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
// Reset everything
finishCheck.Reset();
- actor.SetProperty( Actor::Property::COLOR,Color::WHITE);
+ actor.SetProperty(Actor::Property::COLOR, Color::WHITE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::WHITE, TEST_LOCATION);
// Repeat with a shorter animator duration
float animatorDuration = 0.5f;
- animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::LINEAR, TimePeriod(animatorDuration));
+ animation = Animation::New(durationSeconds);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR), targetColor, AlphaFunction::LINEAR, TimePeriod(animatorDuration));
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% animation progress, 20% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 10% animation progress, 20% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), twentyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), twentyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 50% animation progress, 100% animator progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 400.0f) /* 50% animation progress, 100% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), targetColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), targetColor, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).r, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).r, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetRed(0.5f);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR_RED), targetRed );
+ float targetRed(0.5f);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR_RED), targetRed);
- float fiftyPercentProgress(startValue + (targetRed - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetRed - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), Vector4( targetRed, startValue, startValue, startValue ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_RED ), targetRed, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Vector4(targetRed, startValue, startValue, startValue), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), targetRed, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).r, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).r, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).r, targetRed, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), targetRed, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).r, targetRed, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), targetRed, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).g, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).g, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetGreen(0.5f);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR_GREEN), targetGreen );
+ float targetGreen(0.5f);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR_GREEN), targetGreen);
- float fiftyPercentProgress(startValue + (targetGreen - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetGreen - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), Vector4( startValue, targetGreen, startValue, startValue ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_GREEN ), targetGreen, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Vector4(startValue, targetGreen, startValue, startValue), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), targetGreen, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).g, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).g, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).g, targetGreen, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), targetGreen, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).g, targetGreen, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), targetGreen, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).b, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).b, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetBlue(0.5f);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR_BLUE), targetBlue );
+ float targetBlue(0.5f);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR_BLUE), targetBlue);
- float fiftyPercentProgress(startValue + (targetBlue - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetBlue - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), Vector4( startValue, startValue, targetBlue, startValue ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_BLUE ), targetBlue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Vector4(startValue, startValue, targetBlue, startValue), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), targetBlue, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).b, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).b, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).b, targetBlue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), targetBlue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).b, targetBlue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), targetBlue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
float startValue(1.0f);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- float targetAlpha(0.5f);
- animation.AnimateTo( Property(actor, Actor::Property::COLOR_ALPHA), targetAlpha );
+ float targetAlpha(0.5f);
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR_ALPHA), targetAlpha);
- float fiftyPercentProgress(startValue + (targetAlpha - startValue)*0.5f);
+ float fiftyPercentProgress(startValue + (targetAlpha - startValue) * 0.5f);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( Actor::Property::COLOR ), Vector4( startValue, startValue, startValue, targetAlpha ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), targetAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::OPACITY ), targetAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Vector4(startValue, startValue, startValue, targetAlpha), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), targetAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::OPACITY), targetAlpha, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, fiftyPercentProgress, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), fiftyPercentProgress, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, fiftyPercentProgress, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), fiftyPercentProgress, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, targetAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), targetAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, targetAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), targetAlpha, TEST_LOCATION);
END_TEST;
}
DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
- KeyFrames keyFrames2( keyFrames);
- DALI_TEST_CHECK( keyFrames2 );
+ KeyFrames keyFrames2(keyFrames);
+ DALI_TEST_CHECK(keyFrames2);
DALI_TEST_EQUALS(keyFrames2.GetType(), Property::FLOAT, TEST_LOCATION);
KeyFrames keyFrames3 = KeyFrames::New();
keyFrames3.Add(0.6f, true);
- DALI_TEST_CHECK( keyFrames3 );
+ DALI_TEST_CHECK(keyFrames3);
DALI_TEST_EQUALS(keyFrames3.GetType(), Property::BOOLEAN, TEST_LOCATION);
keyFrames3 = keyFrames;
- DALI_TEST_CHECK( keyFrames3 );
+ DALI_TEST_CHECK(keyFrames3);
DALI_TEST_EQUALS(keyFrames3.GetType(), Property::FLOAT, TEST_LOCATION);
END_TEST;
DALI_TEST_EQUALS(keyFrames.GetType(), Property::FLOAT, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- keyFrames.Add(1.9f, false);
- }, "mType == value.GetType()" );
+ {
+ keyFrames.Add(1.9f, false);
+ },
+ "mType == value.GetType()");
END_TEST;
}
DALI_TEST_EQUALS(keyFrames.GetType(), Property::BOOLEAN, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
- }, "mType == value.GetType()" );
+ {
+ keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
+ },
+ "mType == value.GetType()");
END_TEST;
}
DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR2, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
- }, "mType == value.GetType()" );
+ {
+ keyFrames.Add(0.7f, Vector3(1.0f, 1.0f, 1.0f));
+ },
+ "mType == value.GetType()");
END_TEST;
}
DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR3, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- keyFrames.Add(0.7f, 1.0f);
- }, "mType == value.GetType()" );
+ {
+ keyFrames.Add(0.7f, 1.0f);
+ },
+ "mType == value.GetType()");
END_TEST;
}
DALI_TEST_EQUALS(keyFrames.GetType(), Property::VECTOR4, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- keyFrames.Add(0.7f, Quaternion(Radian(1.717f), Vector3::XAXIS));
- }, "mType == value.GetType()" );
+ {
+ keyFrames.Add(0.7f, Quaternion(Radian(1.717f), Vector3::XAXIS));
+ },
+ "mType == value.GetType()");
END_TEST;
}
DALI_TEST_EQUALS(keyFrames.GetType(), Property::ROTATION, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- keyFrames.Add(0.7f, 1.1f);
- }, "mType == value.GetType()" );
+ {
+ keyFrames.Add(0.7f, 1.1f);
+ },
+ "mType == value.GetType()");
END_TEST;
}
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.8f, 0.7f);
keyFrames.Add(1.0f, 0.9f);
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR_ALPHA), keyFrames);
// Start the animation
animation.Play();
// Final key frame value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::COLOR_ALPHA ), 0.9f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.1f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.1f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 10% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.3f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.3f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 30% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), 0.25f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.25f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.25f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.25f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 40% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.0f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 400.0f) /* 80% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.7f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.7f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 90% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.8f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.8f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.9f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.9f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.8f, 0.7f);
keyFrames.Add(1.0f, 0.9f);
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR_ALPHA), keyFrames, Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR_ALPHA), keyFrames, Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.1f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.1f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 10% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 10% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.36f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.36f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.36f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.36f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 30% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 30% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.21f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.21f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.21f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.21f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 40% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 40% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.0f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*400.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 400.0f) /* 80% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.7f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.7f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 90% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 90% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.76f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.76f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.76f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.76f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.9f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.9f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.5f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.95f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.90f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.80f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.55f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.525f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.506f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.99375f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.925f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85625f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.7875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
AngleAxis aa(Degree(90), Vector3::XAXIS);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.8f, false);
keyFrames.Add(1.0f, true);
- animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames );
+ animation.AnimateBetween(Property(actor, Actor::Property::VISIBLE), keyFrames);
// Start the animation
animation.Play();
// Final key frame value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
AngleAxis aa(Degree(90), Vector3::XAXIS);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(1.0f, true);
//Cubic interpolation for boolean values should be ignored
- animation.AnimateBetween( Property(actor, Actor::Property::VISIBLE), keyFrames, Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::VISIBLE), keyFrames, Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
AngleAxis aa(Degree(90), Vector3::XAXIS);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
Quaternion start(Radian(aa.angle), aa.axis);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), start, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), start, 0.001f, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
- animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames );
+ animation.AnimateBetween(Property(actor, Actor::Property::ORIENTATION), keyFrames);
// Start the animation
animation.Play();
// Final key frame value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< Quaternion >( Actor::Property::ORIENTATION ), Quaternion( Degree( 60 ), Vector3::ZAXIS ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Quaternion>(Actor::Property::ORIENTATION), Quaternion(Degree(60), Vector3::ZAXIS), TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1);
application.SendNotification();
- Quaternion check( Radian(Degree(60)), Vector3::ZAXIS );
+ Quaternion check(Radian(Degree(60)), Vector3::ZAXIS);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
AngleAxis aa(Degree(90), Vector3::XAXIS);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis));
application.SendNotification();
application.Render(0);
application.GetScene().Add(actor);
Quaternion start(Radian(aa.angle), aa.axis);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), start, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), start, 0.001f, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, AngleAxis(Degree(120), Vector3::XAXIS));
keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
- animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames );
+ animation.AnimateBetween(Property(actor, Actor::Property::ORIENTATION), keyFrames);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(90)), Vector3::XAXIS );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(90)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(120)), Vector3::XAXIS );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(120)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f) );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f));
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(120)), Vector3::YAXIS );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(120)), Vector3::YAXIS);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
// We did expect the animation to finish
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
AngleAxis aa(Degree(90), Vector3::XAXIS);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
Quaternion start(Radian(aa.angle), aa.axis);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), start, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), start, 0.001f, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, AngleAxis(Degree(60), Vector3::ZAXIS));
//Cubic interpolation should be ignored for quaternions
- animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)+1);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1);
application.SendNotification();
- Quaternion check( Radian(Degree(60)), Vector3::ZAXIS );
+ Quaternion check(Radian(Degree(60)), Vector3::ZAXIS);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
AngleAxis aa(Degree(90), Vector3::XAXIS);
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(aa.angle, aa.axis));
application.SendNotification();
application.Render(0);
application.GetScene().Add(actor);
Quaternion start(Radian(aa.angle), aa.axis);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), start, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), start, 0.001f, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(1.0f, AngleAxis(Degree(120), Vector3::YAXIS));
//Cubic interpolation should be ignored for quaternions
- animation.AnimateBetween( Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::ORIENTATION), keyFrames, Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
Quaternion check(Radian(Degree(60)), Vector3::XAXIS);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(90)), Vector3::XAXIS );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(90)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(120)), Vector3::XAXIS );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(120)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f ) );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(101.5)), Vector3(0.5f, 0.5f, 0.0f));
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- check = Quaternion( Radian(Degree(120)), Vector3::YAXIS );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), check, 0.001f, TEST_LOCATION );
+ check = Quaternion(Radian(Degree(120)), Vector3::YAXIS);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), check, 0.001f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.5f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.95f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.90f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.80f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.55f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.525f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.506f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.99375f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.925f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85625f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.7875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
- float delay = 0.5f;
+ float durationSeconds(1.0f);
+ float delay = 0.5f;
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( delay, durationSeconds - delay ) );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
+ application.Render(static_cast<unsigned int>(delay * 1000.0f) /* 0% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.5f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.95f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.90f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.80f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
- float delay = 0.5f;
+ float durationSeconds(1.0f);
+ float delay = 0.5f;
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod( delay, durationSeconds - delay ), Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, TimePeriod(delay, durationSeconds - delay), Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
+ application.Render(static_cast<unsigned int>(delay * 1000.0f) /* 0% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.55f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.525f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.506f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.99375f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.925f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85625f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.7875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
float delay = 0.5f;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ) );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
+ application.Render(static_cast<unsigned int>(delay * 1000.0f) /* 0% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.5f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.5f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.5f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.5f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.95f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.90f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.80f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.95f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.90f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.80f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
float startValue(1.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::COLOR,Vector4(startValue, startValue, startValue, startValue));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(startValue, startValue, startValue, startValue));
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), startValue, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
- float delay = 0.5f;
+ float durationSeconds(1.0f);
+ float delay = 0.5f;
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.5f, Vector4(0.9f, 0.8f, 0.7f, 0.6f));
keyFrames.Add(1.0f, Vector4(1.0f, 1.0f, 1.0f, 1.0f));
- animation.AnimateBetween( Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod( delay, durationSeconds - delay ), Animation::CUBIC );
+ animation.AnimateBetween(Property(actor, Actor::Property::COLOR), keyFrames, AlphaFunction::LINEAR, TimePeriod(delay, durationSeconds - delay), Animation::CUBIC);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(delay*1000.0f)/* 0% progress */);
+ application.Render(static_cast<unsigned int>(delay * 1000.0f) /* 0% progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.1f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.2f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.3f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.1f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.2f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.3f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 25% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.55f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.525f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.506f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.4875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.55f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.525f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.506f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.4875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 50% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.9f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.8f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.7f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.6f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.9f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.8f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.7f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.6f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) /* 75% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 0.99375f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 0.925f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 0.85625f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 0.7875f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 0.99375f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 0.925f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 0.85625f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 0.7875f, 0.01f, TEST_LOCATION);
- application.Render(static_cast<unsigned int>((durationSeconds - delay)*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>((durationSeconds - delay) * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_RED ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_GREEN ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_BLUE ), 1.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::COLOR_ALPHA ), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_RED), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_GREEN), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_BLUE), 1.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::COLOR_ALPHA), 1.0f, 0.01f, TEST_LOCATION);
// We did expect the animation to finish
application.GetScene().Add(actor);
//Build the path
- Vector3 position0( 30.0, 80.0, 0.0);
- Vector3 position1( 70.0, 120.0, 0.0);
- Vector3 position2( 100.0, 100.0, 0.0);
+ Vector3 position0(30.0, 80.0, 0.0);
+ Vector3 position1(70.0, 120.0, 0.0);
+ Vector3 position2(100.0, 100.0, 0.0);
Dali::Path path = Dali::Path::New();
path.AddPoint(position0);
path.AddPoint(position2);
//Control points for first segment
- path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
- path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+ path.AddControlPoint(Vector3(39.0, 90.0, 0.0));
+ path.AddControlPoint(Vector3(56.0, 119.0, 0.0));
//Control points for second segment
- path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
- path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
+ path.AddControlPoint(Vector3(78.0, 120.0, 0.0));
+ path.AddControlPoint(Vector3(93.0, 104.0, 0.0));
// Build the animation
- float durationSeconds( 1.0f );
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
animation.Animate(actor, path, Vector3::XAXIS);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- Vector3 position, tangent;
+ Vector3 position, tangent;
Quaternion rotation;
- path.Sample( 0.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- path.Sample( 0.25f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.25f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- path.Sample( 0.5f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.5f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- path.Sample( 0.75f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.75f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- path.Sample( 1.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(1.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
application.GetScene().Add(actor);
//Build the path
- Vector3 position0( 30.0, 80.0, 0.0);
- Vector3 position1( 70.0, 120.0, 0.0);
- Vector3 position2( 100.0, 100.0, 0.0);
+ Vector3 position0(30.0, 80.0, 0.0);
+ Vector3 position1(70.0, 120.0, 0.0);
+ Vector3 position2(100.0, 100.0, 0.0);
Dali::Path path = Dali::Path::New();
path.AddPoint(position0);
path.AddPoint(position2);
//Control points for first segment
- path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
- path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+ path.AddControlPoint(Vector3(39.0, 90.0, 0.0));
+ path.AddControlPoint(Vector3(56.0, 119.0, 0.0));
//Control points for second segment
- path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
- path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
+ path.AddControlPoint(Vector3(78.0, 120.0, 0.0));
+ path.AddControlPoint(Vector3(93.0, 104.0, 0.0));
// Build the animation
- float durationSeconds( 1.0f );
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- Vector3 position, tangent;
+ Vector3 position, tangent;
Quaternion rotation;
- path.Sample( 0.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- path.Sample( 0.25f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.25f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- path.Sample( 0.5f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.5f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- path.Sample( 0.75f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.75f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- path.Sample( 1.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(1.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
application.GetScene().Add(actor);
//Build the path
- Vector3 position0( 30.0, 80.0, 0.0);
- Vector3 position1( 70.0, 120.0, 0.0);
- Vector3 position2( 100.0, 100.0, 0.0);
+ Vector3 position0(30.0, 80.0, 0.0);
+ Vector3 position1(70.0, 120.0, 0.0);
+ Vector3 position2(100.0, 100.0, 0.0);
Dali::Path path = Dali::Path::New();
path.AddPoint(position0);
path.AddPoint(position2);
//Control points for first segment
- path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
- path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+ path.AddControlPoint(Vector3(39.0, 90.0, 0.0));
+ path.AddControlPoint(Vector3(56.0, 119.0, 0.0));
//Control points for second segment
- path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
- path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
+ path.AddControlPoint(Vector3(78.0, 120.0, 0.0));
+ path.AddControlPoint(Vector3(93.0, 104.0, 0.0));
// Build the animation
- float durationSeconds( 1.0f );
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
animation.Animate(actor, path, Vector3::XAXIS, TimePeriod(0.0f, 1.0f));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- Vector3 position, tangent;
+ Vector3 position, tangent;
Quaternion rotation;
- path.Sample( 0.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- path.Sample( 0.25f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.25f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- path.Sample( 0.5f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.5f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- path.Sample( 0.75f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.75f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- path.Sample( 1.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(1.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
application.GetScene().Add(actor);
//Build the path
- Vector3 position0( 30.0, 80.0, 0.0);
- Vector3 position1( 70.0, 120.0, 0.0);
- Vector3 position2( 100.0, 100.0, 0.0);
+ Vector3 position0(30.0, 80.0, 0.0);
+ Vector3 position1(70.0, 120.0, 0.0);
+ Vector3 position2(100.0, 100.0, 0.0);
Dali::Path path = Dali::Path::New();
path.AddPoint(position0);
path.AddPoint(position2);
//Control points for first segment
- path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
- path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+ path.AddControlPoint(Vector3(39.0, 90.0, 0.0));
+ path.AddControlPoint(Vector3(56.0, 119.0, 0.0));
//Control points for second segment
- path.AddControlPoint(Vector3( 78.0, 120.0, 0.0));
- path.AddControlPoint(Vector3( 93.0, 104.0, 0.0));
+ path.AddControlPoint(Vector3(78.0, 120.0, 0.0));
+ path.AddControlPoint(Vector3(93.0, 104.0, 0.0));
// Build the animation
- float durationSeconds( 1.0f );
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
animation.Animate(actor, path, Vector3::XAXIS, AlphaFunction::LINEAR, TimePeriod(0.0f, 1.0f));
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
application.Render(0);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- Vector3 position, tangent;
+ Vector3 position, tangent;
Quaternion rotation;
- path.Sample( 0.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
application.SendNotification();
- path.Sample( 0.25f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.25f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
application.SendNotification();
- path.Sample( 0.5f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.5f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
application.SendNotification();
- path.Sample( 0.75f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(0.75f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)+1/* 100% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1 /* 100% progress */);
application.SendNotification();
- path.Sample( 1.0f, position, tangent );
- rotation = Quaternion( Vector3::XAXIS, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION ), rotation, TEST_LOCATION );
+ path.Sample(1.0f, position, tangent);
+ rotation = Quaternion(Vector3::XAXIS, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::ORIENTATION), rotation, TEST_LOCATION);
finishCheck.CheckSignalReceived();
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(!actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.GetScene().Add(actor);
// Start the animation
- float durationSeconds(10.0f);
+ float durationSeconds(10.0f);
Animation animation = Animation::New(durationSeconds);
- animation.Show(actor, durationSeconds*0.5f);
+ animation.Show(actor, durationSeconds * 0.5f);
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*490.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 490.0f));
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(!actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f)/*Should be shown now*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) /*Should be shown now*/);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.GetScene().Add(actor);
// Start the animation
- float durationSeconds(10.0f);
+ float durationSeconds(10.0f);
Animation animation = Animation::New(durationSeconds);
- animation.Hide(actor, durationSeconds*0.5f);
+ animation.Hide(actor, durationSeconds * 0.5f);
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*490.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * 490.0f));
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*10.0f)/*Should be hidden now*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 10.0f) /*Should be hidden now*/);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(!actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(!actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
application.GetScene().Add(actor);
// Start Hide animation
- float durationSeconds(10.0f);
+ float durationSeconds(10.0f);
Animation animation = Animation::New(durationSeconds);
- animation.Hide(actor, durationSeconds/*Hide at end*/);
+ animation.Hide(actor, durationSeconds /*Hide at end*/);
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( !actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(!actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
// Start Show animation
animation = Animation::New(durationSeconds);
- animation.Show(actor, durationSeconds/*Show at end*/);
+ animation.Show(actor, durationSeconds /*Show at end*/);
animation.FinishedSignal().Connect(&application, finishCheck);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*1000.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_CHECK( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) );
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
END_TEST;
}
KeyFrames* keyFrames = new KeyFrames;
delete keyFrames;
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
TestApplication application;
tet_infoline("Testing Dali::Animation::KeyFramesDownCast()");
- KeyFrames keyFrames = KeyFrames::New();
+ KeyFrames keyFrames = KeyFrames::New();
BaseHandle object(keyFrames);
KeyFrames keyFrames2 = KeyFrames::DownCast(object);
DALI_TEST_CHECK(keyFrames2);
- KeyFrames keyFrames3 = DownCast< KeyFrames >(object);
+ KeyFrames keyFrames3 = DownCast<KeyFrames>(object);
DALI_TEST_CHECK(keyFrames3);
BaseHandle unInitializedObject;
- KeyFrames keyFrames4 = KeyFrames::DownCast(unInitializedObject);
+ KeyFrames keyFrames4 = KeyFrames::DownCast(unInitializedObject);
DALI_TEST_CHECK(!keyFrames4);
- KeyFrames keyFrames5 = DownCast< KeyFrames >(unInitializedObject);
+ KeyFrames keyFrames5 = DownCast<KeyFrames>(unInitializedObject);
DALI_TEST_CHECK(!keyFrames5);
END_TEST;
}
int UtcDaliAnimationCreateDestroyP(void)
{
TestApplication application;
- Animation* animation = new Animation;
- DALI_TEST_CHECK( animation );
+ Animation* animation = new Animation;
+ DALI_TEST_CHECK(animation);
delete animation;
END_TEST;
}
{
}
- void operator()( Vector3& current, const PropertyInputContainer& /* inputs */)
+ void operator()(Vector3& current, const PropertyInputContainer& /* inputs */)
{
- mApplication.SendNotification(); // Process events
+ mApplication.SendNotification(); // Process events
}
TestApplication& mApplication;
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Build the animation
- Animation animation = Animation::New( 0.0f );
+ Animation animation = Animation::New(0.0f);
- bool signalReceived = false;
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived = false;
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
- Vector3 startValue(1.0f, 1.0f, 1.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
- Constraint constraint = Constraint::New<Vector3>( actor, index, UpdateManagerTestConstraint( application ) );
+ Vector3 startValue(1.0f, 1.0f, 1.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
+ Constraint constraint = Constraint::New<Vector3>(actor, index, UpdateManagerTestConstraint(application));
constraint.Apply();
// Apply animation to actor
- animation.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 100.f, 90.f, 80.f ), AlphaFunction::LINEAR );
- animation.AnimateTo( Property(actor, Actor::Property::OPACITY), 0.3f, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(100.f, 90.f, 80.f), AlphaFunction::LINEAR);
+ animation.AnimateTo(Property(actor, Actor::Property::OPACITY), 0.3f, AlphaFunction::LINEAR);
animation.Play();
application.SendNotification();
- application.UpdateOnly( 16 );
+ application.UpdateOnly(16);
finishCheck.CheckSignalNotReceived();
- application.SendNotification(); // Process events
+ application.SendNotification(); // Process events
finishCheck.CheckSignalReceived();
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Build the animations
- Animation animation1 = Animation::New( 0.0f ); // finishes first frame
- Animation animation2 = Animation::New( 0.02f ); // finishes in 20 ms
+ Animation animation1 = Animation::New(0.0f); // finishes first frame
+ Animation animation2 = Animation::New(0.02f); // finishes in 20 ms
bool signal1Received = false;
- animation1.FinishedSignal().Connect( &application, AnimationFinishCheck( signal1Received ) );
+ animation1.FinishedSignal().Connect(&application, AnimationFinishCheck(signal1Received));
bool signal2Received = false;
- animation2.FinishedSignal().Connect( &application, AnimationFinishCheck( signal2Received ) );
+ animation2.FinishedSignal().Connect(&application, AnimationFinishCheck(signal2Received));
// Apply animations to actor
- animation1.AnimateTo( Property(actor, Actor::Property::POSITION), Vector3( 3.0f, 2.0f, 1.0f ), AlphaFunction::LINEAR );
+ animation1.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(3.0f, 2.0f, 1.0f), AlphaFunction::LINEAR);
animation1.Play();
- animation2.AnimateTo( Property(actor, Actor::Property::SIZE ), Vector3( 10.0f, 20.0f, 30.0f ), AlphaFunction::LINEAR );
+ animation2.AnimateTo(Property(actor, Actor::Property::SIZE), Vector3(10.0f, 20.0f, 30.0f), AlphaFunction::LINEAR);
animation2.Play();
- DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
- DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(signal1Received, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(signal2Received, false, TEST_LOCATION);
application.SendNotification();
- application.UpdateOnly( 10 ); // 10ms progress
+ application.UpdateOnly(10); // 10ms progress
// no notifications yet
- DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
- DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(signal1Received, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(signal2Received, false, TEST_LOCATION);
application.SendNotification();
// first completed
- DALI_TEST_EQUALS( signal1Received, true, TEST_LOCATION );
- DALI_TEST_EQUALS( signal2Received, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(signal1Received, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(signal2Received, false, TEST_LOCATION);
signal1Received = false;
// 1st animation is complete now, do another update with no ProcessEvents in between
- application.UpdateOnly( 20 ); // 20ms progress
+ application.UpdateOnly(20); // 20ms progress
// ProcessEvents
application.SendNotification();
// 2nd should complete now
- DALI_TEST_EQUALS( signal1Received, false, TEST_LOCATION );
- DALI_TEST_EQUALS( signal2Received, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(signal1Received, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(signal2Received, true, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register a float property
- float startValue(10.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ float startValue(10.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<float>(index), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
// Build the animation
- float initialDurationSeconds(1.0f);
- float animatorDelay = 5.0f;
- float animatorDurationSeconds(5.0f);
- float extendedDurationSeconds(animatorDelay+animatorDurationSeconds);
+ float initialDurationSeconds(1.0f);
+ float animatorDelay = 5.0f;
+ float animatorDurationSeconds(5.0f);
+ float extendedDurationSeconds(animatorDelay + animatorDurationSeconds);
Animation animation = Animation::New(initialDurationSeconds);
- float targetValue(30.0f);
- float relativeValue(targetValue - startValue);
+ float targetValue(30.0f);
+ float relativeValue(targetValue - startValue);
animation.AnimateTo(Property(actor, index),
targetValue,
TimePeriod(animatorDelay, animatorDurationSeconds));
// The duration should have been extended
- DALI_TEST_EQUALS( animation.GetDuration(), extendedDurationSeconds, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetDuration(), extendedDurationSeconds, TEST_LOCATION);
// Start the animation
animation.Play();
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(extendedDurationSeconds*500.0f)/* 50% animation progress, 0% animator progress */);
+ application.Render(static_cast<unsigned int>(extendedDurationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet, but cached value should be the final one
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f)/* 75% animation progress, 50% animator progress */);
+ application.Render(static_cast<unsigned int>(extendedDurationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue+(relativeValue*0.5f), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue + (relativeValue * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(extendedDurationSeconds*250.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(extendedDurationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), targetValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), targetValue, TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
int startValue(0u);
- Property::Index index = actor.RegisterProperty("anIndex", startValue);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), startValue, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< int >( index ), startValue, TEST_LOCATION );
+ Property::Index index = actor.RegisterProperty("anIndex", startValue);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), startValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.AnimateTo( Property(actor, index), 20 );
+ animation.AnimateTo(Property(actor, index), 20);
// Start the animation
animation.Play();
// Target value should be retrievable straight away
- DALI_TEST_EQUALS( actor.GetProperty< int >( index ), 20, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), 20, TEST_LOCATION);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f)/* 50% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), 10, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< int >( index ), 20, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< int >( index ), 20, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<int>(index), 20, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), 20, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- Animation animation = Animation::New( 0.0f );
- DALI_TEST_EQUALS( 0.0f, animation.GetDuration(), TEST_LOCATION );
+ Animation animation = Animation::New(0.0f);
+ DALI_TEST_EQUALS(0.0f, animation.GetDuration(), TEST_LOCATION);
// The animation duration should automatically increase depending on the animator time period
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 100.0f, TimePeriod( 0.0f, 1.0f ) );
- DALI_TEST_EQUALS( 1.0f, animation.GetDuration(), TEST_LOCATION );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 100.0f, TimePeriod(0.0f, 1.0f));
+ DALI_TEST_EQUALS(1.0f, animation.GetDuration(), TEST_LOCATION);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_Y ), 200.0f, TimePeriod( 10.0f, 1.0f ) );
- DALI_TEST_EQUALS( 11.0f, animation.GetDuration(), TEST_LOCATION );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_Y), 200.0f, TimePeriod(10.0f, 1.0f));
+ DALI_TEST_EQUALS(11.0f, animation.GetDuration(), TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(1);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(1);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- // Build the animation
- Animation animation = Animation::New( 2.0f );
- std::string relativeValue = "relative string";
- animation.AnimateBy( Property(actor, index), relativeValue );
- tet_result(TET_FAIL);
- }, "Target value is not animatable" );
+ {
+ // Build the animation
+ Animation animation = Animation::New(2.0f);
+ std::string relativeValue = "relative string";
+ animation.AnimateBy(Property(actor, index), relativeValue);
+ tet_result(TET_FAIL);
+ },
+ "Target value is not animatable");
END_TEST;
}
-
int UtcDaliAnimationAnimateToNonAnimateableTypeN(void)
{
TestApplication application;
Actor actor = Actor::New();
// Register an integer property
- int startValue(1);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(1);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- // Build the animation
- Animation animation = Animation::New( 2.0f );
- std::string relativeValue = "relative string";
- animation.AnimateTo( Property(actor, index), relativeValue );
- }, "Target value is not animatable" );
+ {
+ // Build the animation
+ Animation animation = Animation::New(2.0f);
+ std::string relativeValue = "relative string";
+ animation.AnimateTo(Property(actor, index), relativeValue);
+ },
+ "Target value is not animatable");
END_TEST;
}
Actor actor = Actor::New();
// Register an integer property
- int startValue(1);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
+ int startValue(1);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( actor.GetProperty<int>(index), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
DALI_TEST_ASSERTION(
- {
- // Build the animation
- KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add( 0.0f, std::string("relative string1") );
- keyFrames.Add( 1.0f, std::string("relative string2") );
- // no need to really create the animation as keyframes do the check
- }, "Property type is not animatable" );
+ {
+ // Build the animation
+ KeyFrames keyFrames = KeyFrames::New();
+ keyFrames.Add(0.0f, std::string("relative string1"));
+ keyFrames.Add(1.0f, std::string("relative string2"));
+ // no need to really create the animation as keyframes do the check
+ },
+ "Property type is not animatable");
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
Vector3 initialPosition(0.0f, 0.0f, 0.0f);
- actor.SetProperty( Actor::Property::POSITION, initialPosition );
+ actor.SetProperty(Actor::Property::POSITION, initialPosition);
// Build the animation
Animation animation = Animation::New(2.0f);
//Test GetCurrentProgress return 0.0 as the duration is 0.0
- DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3( 0.0f, 0.0f, 0.0f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(0.0f, 0.0f, 0.0f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
tet_infoline("Set target position in animation without intiating play");
tet_infoline("Ensure position of actor is still at intial value");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION);
tet_infoline("Play animation and ensure actor position is now target");
tet_infoline("Ensure position of actor is at target value when aninmation half way");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION);
- tet_printf( "x position at half way point(%f)\n", actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x );
+ tet_printf("x position at half way point(%f)\n", actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x);
application.Render(2000u);
tet_infoline("Ensure position of actor is still at target value when aninmation complete");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPosition.z, TEST_LOCATION);
END_TEST;
}
std::vector<Vector3> targetPositions;
- targetPositions.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
- targetPositions.push_back( Vector3( 200.0f, 1.0f, 100.0f ) );
- targetPositions.push_back( Vector3( 50.0f, 10.0f, 100.0f ) );
+ targetPositions.push_back(Vector3(100.0f, 100.0f, 100.0f));
+ targetPositions.push_back(Vector3(200.0f, 1.0f, 100.0f));
+ targetPositions.push_back(Vector3(50.0f, 10.0f, 100.0f));
tet_infoline("Set initial position and set up animation to re-position actor");
Actor actor = Actor::New();
application.GetScene().Add(actor);
Vector3 initialPosition(0.0f, 0.0f, 0.0f);
- actor.SetProperty( Actor::Property::POSITION, initialPosition );
+ actor.SetProperty(Actor::Property::POSITION, initialPosition);
// Build the animation
Animation animation = Animation::New(2.0f);
//Test GetCurrentProgress return 0.0 as the duration is 0.0
- DALI_TEST_EQUALS( 0.0f, animation.GetCurrentProgress(), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3( 0.0f, 0.0f, 0.0f ), actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.0f, animation.GetCurrentProgress(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(0.0f, 0.0f, 0.0f), actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
tet_infoline("Set target position in animation without intiating play");
- for ( unsigned int i = 0; i < targetPositions.size(); i++ )
+ for(unsigned int i = 0; i < targetPositions.size(); i++)
{
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPositions[i], AlphaFunction::LINEAR);
}
tet_infoline("Ensure position of actor is still at intial value");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), initialPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), initialPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), initialPosition.z, TEST_LOCATION);
tet_infoline("Play animation and ensure actor position is now target");
tet_infoline("Ensure position of actor is at target value when aninmation half way");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION);
- tet_printf( "x position at half way point(%f)\n", actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ).x );
+ tet_printf("x position at half way point(%f)\n", actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION).x);
application.Render(2000u);
tet_infoline("Ensure position of actor is still at target value when aninmation complete");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[2].x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[2].y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[2].z, TEST_LOCATION);
END_TEST;
}
std::vector<Vector3> targetSizes;
std::vector<Vector3> targetPositions;
- targetSizes.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
- targetSizes.push_back( Vector3( 50.0f, 10.0f, 100.0f ) );
+ targetSizes.push_back(Vector3(100.0f, 100.0f, 100.0f));
+ targetSizes.push_back(Vector3(50.0f, 10.0f, 100.0f));
- targetPositions.push_back( Vector3( 200.0f, 1.0f, 100.0f ) );
+ targetPositions.push_back(Vector3(200.0f, 1.0f, 100.0f));
tet_infoline("Set initial position and set up animation to re-position actor");
Actor actor = Actor::New();
application.GetScene().Add(actor);
- Vector3 initialSize( 10.0f, 10.0f, 10.0f);
+ Vector3 initialSize(10.0f, 10.0f, 10.0f);
Vector3 initialPosition(10.0f, 10.0f, 10.0f);
- actor.SetProperty( Actor::Property::SIZE, initialSize );
- actor.SetProperty( Actor::Property::POSITION, initialPosition );
+ actor.SetProperty(Actor::Property::SIZE, initialSize);
+ actor.SetProperty(Actor::Property::POSITION, initialPosition);
// Build the animation
Animation animation = Animation::New(2.0f);
tet_infoline("Ensure position of actor is still at intial size and position");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialPosition.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialPosition.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialPosition.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialPosition.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialPosition.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialPosition.z, TEST_LOCATION);
tet_infoline("Play animation and ensure actor position and size is now matches targets");
tet_infoline("Ensure position and size of actor is at target value when aninmation playing");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[0].x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[0].y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[0].z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), targetPositions[0].x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Y), targetPositions[0].y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_Z), targetPositions[0].z, TEST_LOCATION);
END_TEST;
}
TestApplication application;
std::vector<Vector3> targetSizes;
- std::vector<float> targetColors;
+ std::vector<float> targetColors;
- targetSizes.push_back( Vector3( 100.0f, 100.0f, 100.0f ) );
- targetSizes.push_back( Vector3( 50.0f, 10.0f, 150.0f ) );
+ targetSizes.push_back(Vector3(100.0f, 100.0f, 100.0f));
+ targetSizes.push_back(Vector3(50.0f, 10.0f, 150.0f));
- targetColors.push_back( 1.0f );
+ targetColors.push_back(1.0f);
tet_infoline("Set initial position and set up animation to re-position actor");
Actor actor = Actor::New();
application.GetScene().Add(actor);
- Vector3 initialSize( 10.0f, 5.0f, 10.0f);
+ Vector3 initialSize(10.0f, 5.0f, 10.0f);
- actor.SetProperty( Actor::Property::SIZE, initialSize );
+ actor.SetProperty(Actor::Property::SIZE, initialSize);
// Build the animation
Animation animation = Animation::New(2.0f);
tet_infoline("Ensure position of actor is still at initial size and position");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), initialSize.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), initialSize.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), initialSize.z, TEST_LOCATION);
tet_infoline("Play animation and ensure actor position and size is now matches targets");
tet_infoline("Ensure position and size of actor is at target value when animation playing");
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_WIDTH), targetSizes[1].x, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_HEIGHT), targetSizes[1].y, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::SIZE_DEPTH), targetSizes[1].z, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColors[0], TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), targetColors[0], TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationTimePeriodOrder(void)
{
- tet_infoline("Animate the same property with different time periods and ensure it runs correctly and ends up in the right place" );
+ tet_infoline("Animate the same property with different time periods and ensure it runs correctly and ends up in the right place");
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
//////////////////////////////////////////////////////////////////////////////////
- tet_infoline( "With two AnimateTo calls" );
+ tet_infoline("With two AnimateTo calls");
- Animation animation = Animation::New( 0.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 100.0f, TimePeriod( 3.0f, 1.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 10.0f, TimePeriod( 1.0f, 1.0f ) );
+ Animation animation = Animation::New(0.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 100.0f, TimePeriod(3.0f, 1.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 10.0f, TimePeriod(1.0f, 1.0f));
animation.Play();
- tet_infoline( "The target position should change instantly" );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 100.0f, TEST_LOCATION );
+ tet_infoline("The target position should change instantly");
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 100.0f, TEST_LOCATION);
application.SendNotification();
application.Render(5000); // After the animation is complete
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 100.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 100.0f, TEST_LOCATION);
//////////////////////////////////////////////////////////////////////////////////
- tet_infoline( "Same animation again but in a different order - should yield the same result" );
+ tet_infoline("Same animation again but in a different order - should yield the same result");
- actor.SetProperty( Actor::Property::POSITION_X, 0.0f );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
+ actor.SetProperty(Actor::Property::POSITION_X, 0.0f);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
- animation = Animation::New( 0.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 10.0f, TimePeriod( 1.0f, 1.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 100.0f, TimePeriod( 3.0f, 1.0f ) );
+ animation = Animation::New(0.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 10.0f, TimePeriod(1.0f, 1.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 100.0f, TimePeriod(3.0f, 1.0f));
animation.Play();
- tet_infoline( "The target position should change instantly" );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 100.0f, TEST_LOCATION );
+ tet_infoline("The target position should change instantly");
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 100.0f, TEST_LOCATION);
application.SendNotification();
application.Render(5000); // After the animation is complete
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 100.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 100.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationTimePeriodOrderSeveralAnimateToCalls(void)
{
- tet_infoline("Animate the same property with different time periods and ensure it runs correctly and ends up in the right place with several AnimateTo calls" );
+ tet_infoline("Animate the same property with different time periods and ensure it runs correctly and ends up in the right place with several AnimateTo calls");
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
//////////////////////////////////////////////////////////////////////////////////
- tet_infoline( "" );
+ tet_infoline("");
- Animation animation = Animation::New( 0.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 1000.0f, TimePeriod( 4.0f, 2.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 145.0f, TimePeriod( 3.0f, 10.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 109.0f, TimePeriod( 1.0f, 1.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 1.0f, TimePeriod( 3.0f, 4.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 200.0f, TimePeriod( 2.0f, 5.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 10.0f, TimePeriod( 10.0f, 2.0f ) );
+ Animation animation = Animation::New(0.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 1000.0f, TimePeriod(4.0f, 2.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 145.0f, TimePeriod(3.0f, 10.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 109.0f, TimePeriod(1.0f, 1.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 1.0f, TimePeriod(3.0f, 4.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 200.0f, TimePeriod(2.0f, 5.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 10.0f, TimePeriod(10.0f, 2.0f));
animation.Play();
- tet_infoline( "The target position should change instantly" );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 145.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 145.0f, TEST_LOCATION );
+ tet_infoline("The target position should change instantly");
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(145.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 145.0f, TEST_LOCATION);
application.SendNotification();
application.Render(14000); // After the animation is complete
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 145.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 145.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 145.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(145.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(145.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 145.0f, TEST_LOCATION);
//////////////////////////////////////////////////////////////////////////////////
- tet_infoline( "Same animation again but in a different order - should end up at the same point" );
+ tet_infoline("Same animation again but in a different order - should end up at the same point");
- actor.SetProperty( Actor::Property::POSITION_X, 0.0f );
+ actor.SetProperty(Actor::Property::POSITION_X, 0.0f);
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 0.0f, TEST_LOCATION);
- animation = Animation::New( 0.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 200.0f, TimePeriod( 2.0f, 5.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 10.0f, TimePeriod( 10.0f, 2.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 145.0f, TimePeriod( 3.0f, 10.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 1000.0f, TimePeriod( 4.0f, 2.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 1.0f, TimePeriod( 3.0f, 4.0f ) );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 109.0f, TimePeriod( 1.0f, 1.0f ) );
+ animation = Animation::New(0.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 200.0f, TimePeriod(2.0f, 5.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 10.0f, TimePeriod(10.0f, 2.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 145.0f, TimePeriod(3.0f, 10.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 1000.0f, TimePeriod(4.0f, 2.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 1.0f, TimePeriod(3.0f, 4.0f));
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 109.0f, TimePeriod(1.0f, 1.0f));
animation.Play();
- tet_infoline( "The target position should change instantly" );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 145.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( Actor::Property::POSITION_X ), 145.0f, TEST_LOCATION );
+ tet_infoline("The target position should change instantly");
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::POSITION), Vector3(145.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::POSITION_X), 145.0f, TEST_LOCATION);
application.SendNotification();
application.Render(14000); // After the animation is complete
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 145.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 145.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( Actor::Property::POSITION_X ), 145.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(145.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(145.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(Actor::Property::POSITION_X), 145.0f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- int startValue(1);
- Actor actor = Actor::New();
- const Property::Index index = actor.RegisterProperty("customProperty", startValue );
+ int startValue(1);
+ Actor actor = Actor::New();
+ const Property::Index index = actor.RegisterProperty("customProperty", startValue);
application.GetScene().Add(actor);
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetProperty< int >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.8f, 50);
keyFrames.Add(1.0f, 60);
- animation.AnimateBetween( Property(actor, index ), keyFrames );
+ animation.AnimateBetween(Property(actor, index), keyFrames);
// Start the animation
animation.Play();
// Target value should change to the last key-frame's value straight away
- DALI_TEST_EQUALS( actor.GetProperty< int >( index ), 60, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<int>(index), 60, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Vector2 startValue( 10.0f, 20.0f );
- Actor actor = Actor::New();
- const Property::Index index = actor.RegisterProperty("customProperty", startValue );
+ Vector2 startValue(10.0f, 20.0f);
+ Actor actor = Actor::New();
+ const Property::Index index = actor.RegisterProperty("customProperty", startValue);
application.GetScene().Add(actor);
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), startValue, TEST_LOCATION);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
KeyFrames keyFrames = KeyFrames::New();
- keyFrames.Add( 0.0f, Vector2( 0.0f, 5.0f ) );
- keyFrames.Add( 0.2f, Vector2( 30.0f, 25.0f ) );
- keyFrames.Add( 0.4f, Vector2( 40.0f, 35.0f ) );
- keyFrames.Add( 0.6f, Vector2( 50.0f, 45.0f ) );
- keyFrames.Add( 0.8f, Vector2( 60.0f, 55.0f ) );
- keyFrames.Add( 1.0f, Vector2( 70.0f, 65.0f ) );
+ keyFrames.Add(0.0f, Vector2(0.0f, 5.0f));
+ keyFrames.Add(0.2f, Vector2(30.0f, 25.0f));
+ keyFrames.Add(0.4f, Vector2(40.0f, 35.0f));
+ keyFrames.Add(0.6f, Vector2(50.0f, 45.0f));
+ keyFrames.Add(0.8f, Vector2(60.0f, 55.0f));
+ keyFrames.Add(1.0f, Vector2(70.0f, 65.0f));
- animation.AnimateBetween( Property(actor, index ), keyFrames );
+ animation.AnimateBetween(Property(actor, index), keyFrames);
// Start the animation
animation.Play();
// Target value should change to the last key-frame's value straight away
- DALI_TEST_EQUALS( actor.GetProperty< Vector2 >( index ), Vector2( 70.0f, 65.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector2>(index), Vector2(70.0f, 65.0f), TEST_LOCATION);
END_TEST;
}
animation.FinishedSignal().Connect(&application, finishCheck);
AnimationProgressCheck progressCheck(progressSignalReceived);
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "Animation Progress notification set to 30%" );
- DevelAnimation::SetProgressNotification( animation, 0.3f );
+ tet_infoline("Animation Progress notification set to 30%");
+ DevelAnimation::SetProgressNotification(animation, 0.3f);
application.SendNotification();
- application.Render( );
+ application.Render();
- DALI_TEST_EQUALS( 0.3f, DevelAnimation::GetProgressNotification( animation ), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.3f, DevelAnimation::GetProgressNotification(animation), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
// Start the animation from 10% progress
- animation.SetCurrentProgress( 0.1f );
+ animation.SetCurrentProgress(0.1f);
animation.Play();
- tet_infoline( "Animation Playing from 10%" );
+ tet_infoline("Animation Playing from 10%");
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*100.0f ); // 20% progress
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 100.0f); // 20% progress
- tet_infoline( "Animation at 20%" );
+ tet_infoline("Animation at 20%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*200.0f ); // 40% progress
+ application.Render(durationSeconds * 200.0f); // 40% progress
application.SendNotification();
- tet_infoline( "Animation at 40%" );
- DALI_TEST_EQUALS( 0.4f, animation.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 40%");
+ DALI_TEST_EQUALS(0.4f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheck.Reset();
- application.Render(durationSeconds*100.0f ); // 50% progress
- tet_infoline( "Animation at 50%" );
+ application.Render(durationSeconds * 100.0f); // 50% progress
+ tet_infoline("Animation at 50%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.5f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 60% progress */);
application.SendNotification();
- tet_infoline( "Animation at 60%" );
+ tet_infoline("Animation at 60%");
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
application.SendNotification();
- DALI_TEST_EQUALS( 0.8f, animation.GetCurrentProgress(), TEST_LOCATION );
- tet_infoline( "Animation at 80%" );
+ DALI_TEST_EQUALS(0.8f, animation.GetCurrentProgress(), TEST_LOCATION);
+ tet_infoline("Animation at 80%");
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- tet_infoline( "Animation finished" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ tet_infoline("Animation finished");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR, TimePeriod( 0.5f, 0.5f ) );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
// Play animation after the initial delay time
- animation.PlayAfter( 0.2f );
+ animation.PlayAfter(0.2f);
application.SendNotification();
application.Render(0); // start animation
- application.Render( durationSeconds * 200.f ); // The intial delay time of PlayAfter
+ application.Render(durationSeconds * 200.f); // The intial delay time of PlayAfter
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 50% animation progress, 0% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of TimePeriod in seconds
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 75% animation progress, 50% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.5f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f ) + 1u/*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
tet_printf("Testing that playing after 2 seconds with negative speedfactor\n");
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetSpeedFactor( -1.0f ); // Set SpeedFactor as < 0
+ animation.SetSpeedFactor(-1.0f); // Set SpeedFactor as < 0
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR, TimePeriod( 0.5f, 0.5f ) );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
// Play animation after the initial delay time
- animation.PlayAfter( 0.2f );
+ animation.PlayAfter(0.2f);
application.SendNotification();
application.Render(0); // start animation
- application.Render( durationSeconds * 200.f ); // The intial delay time of PlayAfter
+ application.Render(durationSeconds * 200.f); // The intial delay time of PlayAfter
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 1.0f ), TEST_LOCATION ); // Not move. NOTE SpeedFactor < 0 so 'targetPosition' is start position.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 1.0f), TEST_LOCATION); // Not move. NOTE SpeedFactor < 0 so 'targetPosition' is start position.
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 25% animation progress, 50% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.5f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 50% animation progress, 100% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% animation progress, 100% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f ) + 1u/*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of Timeperiod in seconds
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of Timeperiod in seconds
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(0.0, 0.0, 0.0), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0, 0.0, 0.0), TEST_LOCATION);
}
END_TEST;
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetLooping( true );
+ animation.SetLooping(true);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR, TimePeriod( 0.5f, 0.5f ) );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
// Play animation after the initial delay time
- animation.PlayAfter( 0.2f );
+ animation.PlayAfter(0.2f);
application.SendNotification();
application.Render(0); // start animation
- for( int iterations = 0; iterations < 3; ++iterations )
+ for(int iterations = 0; iterations < 3; ++iterations)
{
// The initial delay time of PlayAfter() applies only once in looping mode.
- if( iterations == 0 )
+ if(iterations == 0)
{
- application.Render( durationSeconds * 200.f ); // The intial delay time of PlayAfter
+ application.Render(durationSeconds * 200.f); // The intial delay time of PlayAfter
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move
}
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 50% animation progress, 0% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of TimePeriod in seconds
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 75% animation progress, 50% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.5f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f ) /* 100% progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% progress */);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
animation.SetLooping(false);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 1000.0f ) + 1u /*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
tet_printf("Testing that playing after 2 seconds before looping with negative speedfactor\n");
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- animation.SetLooping( true );
- animation.SetSpeedFactor( -1.0f ); //Set SpeedFactor as < 0
+ animation.SetLooping(true);
+ animation.SetSpeedFactor(-1.0f); //Set SpeedFactor as < 0
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR, TimePeriod( 0.5f, 0.5f ) );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
// Play animation after the initial delay time
- animation.PlayAfter( 0.2f );
+ animation.PlayAfter(0.2f);
application.SendNotification();
application.Render(0); // start animation
- for( int iterations = 0; iterations < 3; ++iterations )
+ for(int iterations = 0; iterations < 3; ++iterations)
{
// The initial delay time of PlayAfter() applies only once in looping mode.
- if( iterations == 0 )
+ if(iterations == 0)
{
- application.Render( durationSeconds * 200.f ); // The intial delay time of PlayAfter
+ application.Render(durationSeconds * 200.f); // The intial delay time of PlayAfter
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 1.0f ), TEST_LOCATION ); // Not move. NOTE SpeedFactor < 0 so 'targetPosition' is start position.
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 1.0f), TEST_LOCATION); // Not move. NOTE SpeedFactor < 0 so 'targetPosition' is start position.
}
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 25% animation progress, 50% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% animation progress, 50% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.5f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 50% animation progress, 100% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% animation progress, 100% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f ) /* 100% progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 100% progress */);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of TimePeriod in second
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in second
}
animation.SetLooping(false);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 1000.0f ) + 1u /*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3(0.0, 0.0, 0.0), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0, 0.0, 0.0), TEST_LOCATION);
}
END_TEST;
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR, TimePeriod( 0.5f, 0.5f ) );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
// When the delay time is negative value, it would treat as play immediately.
- animation.PlayAfter( -2.0f );
+ animation.PlayAfter(-2.0f);
application.SendNotification();
application.Render(0); // start animation
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 50% animation progress, 0% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of TimePeriod in seconds
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 75% animation progress, 50% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% animation progress, 50% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.5f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.5f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f ) + 1u/*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
application.GetScene().Add(actor);
// Build the animation
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
- Vector3 targetPosition( 100.0f, 100.0f, 100.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR, TimePeriod( 0.5f, 0.5f ) );
+ Vector3 targetPosition(100.0f, 100.0f, 100.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR, TimePeriod(0.5f, 0.5f));
// Delay time is 0.3s. So after duration times, progress must be 70%. animation will finished at 1.3s.
- animation.PlayAfter( durationSeconds * 0.3f );
+ animation.PlayAfter(durationSeconds * 0.3f);
application.SendNotification();
application.Render(0); // start animation
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 5/6 delay progress, 0% animation progress, 0% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 5/6 delay progress, 0% animation progress, 0% animator progress */);
// We didn't expect the animation to finish yet
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of PlayAfter
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of PlayAfter
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 100% delay progress, 20% animation progress, 0% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 20% animation progress, 0% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of TimePeriod in seconds
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 100% delay progress, 45% animation progress, 0% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 45% animation progress, 0% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.0f ), TEST_LOCATION ); // Not move - A delay time of TimePeriod in seconds
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.0f), TEST_LOCATION); // Not move - A delay time of TimePeriod in seconds
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 100% delay progress, 70% animation progress, 40% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 70% animation progress, 40% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.4f ), TEST_LOCATION ); // 40% of animator progress
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.4f), TEST_LOCATION); // 40% of animator progress
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 250.0f )/* 100% delay progress, 95% animation progress, 90% animator progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% delay progress, 95% animation progress, 90% animator progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), ( targetPosition * 0.9f ), TEST_LOCATION ); // 90% of animator progress
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), (targetPosition * 0.9f), TEST_LOCATION); // 90% of animator progress
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 50.0f ) + 1u/*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 50.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// Check that nothing has changed after a couple of buffer swaps
application.Render(0);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationSetLoopingModeP(void)
{
// Test Loop forever and Loop mode being set
- TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
// Default: LoopingMode::RESTART
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::RESTART );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::RESTART);
Vector3 targetPosition(10.0f, 10.0f, 10.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*0.5f*1000.0f)/*Only half the animation*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /*Only half the animation*/);
actor.Unparent();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
// LoopingMode::AUTO_REVERSE
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
- animation.SetLooping( true );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLooping(true);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
- animation.SetLoopingMode( Animation::LoopingMode::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::LoopingMode::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
// Start the animation
animation.Play();
application.SendNotification();
application.Render(0);
- for( int iterations = 0; iterations < 3; ++iterations )
+ for(int iterations = 0; iterations < 3; ++iterations)
{
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 50% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% time progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// AUTO_REVERSE mode means, for Animation duration time, the actor starts from the beginning, passes the targetPosition,
// and arrives at the beginning.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 100% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 100% time progress */);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
}
- animation.SetLooping( false );
+ animation.SetLooping(false);
application.SendNotification();
- application.Render(static_cast< unsigned int >( durationSeconds * 1000.0f ) + 1u /*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
}
// LoopingMode::AUTO_REVERSE in Reverse mode, which begin from the end
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
- animation.SetLooping( true );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetLooping(true);
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
// Specify a negative multiplier to play the animation in reverse
- animation.SetSpeedFactor( -1.0f );
+ animation.SetSpeedFactor(-1.0f);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
- animation.SetLoopingMode( Animation::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
// Start the animation
animation.Play();
application.SendNotification();
application.Render(0);
- for( int iterations = 0; iterations < 3; ++iterations )
+ for(int iterations = 0; iterations < 3; ++iterations)
{
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 50% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 50% time progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// Setting a negative speed factor is to play the animation in reverse.
// So, when LoopingMode::AUTO_REVERSE and SetSpeedFactor( -1.0f ) is, for Animation duration time,
// the actor starts from the targetPosition, passes the beginning, and arrives at the targetPosition.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 500.0f )/* 100% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 500.0f) /* 100% time progress */);
// We did expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
- animation.SetLooping( false );
+ animation.SetLooping(false);
application.SendNotification();
- application.Render(static_cast< unsigned int >( durationSeconds * 1000.0f ) + 1u /*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
}
END_TEST;
int UtcDaliAnimationSetLoopingModeP2(void)
{
// Test Loop Count and Loop mode being set
- TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
// LoopingMode::AUTO_REVERSE
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
animation.SetLoopCount(3);
DALI_TEST_CHECK(animation.IsLooping());
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
- animation.SetLoopingMode( Animation::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
// Start the animation
animation.Play();
// Loop
float intervalSeconds = 3.0f;
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
// AUTO_REVERSE mode means, for Animation duration time, the actor starts from the beginning, passes the targetPosition,
// and arrives at the beginning.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.Render(0);
application.SendNotification();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
finishCheck.Reset();
}
// LoopingMode::AUTO_REVERSE in Reverse mode, which begin from the end
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
animation.SetLoopCount(3);
DALI_TEST_CHECK(animation.IsLooping());
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
// Specify a negative multiplier to play the animation in reverse
- animation.SetSpeedFactor( -1.0f );
+ animation.SetSpeedFactor(-1.0f);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
- animation.SetLoopingMode( Animation::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
// Start the animation
animation.Play();
// Loop
float intervalSeconds = 3.0f;
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
// Setting a negative speed factor is to play the animation in reverse.
// So, when LoopingMode::AUTO_REVERSE and SetSpeedFactor( -1.0f ) is, for Animation duration time,
// the actor starts from the targetPosition, passes the beginning, and arrives at the targetPosition.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.Render(0);
application.SendNotification();
application.SendNotification();
finishCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*intervalSeconds*1000.0f));
+ application.Render(static_cast<unsigned int>(durationSeconds * intervalSeconds * 1000.0f));
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
finishCheck.Reset();
}
int UtcDaliAnimationSetLoopingModeP3(void)
{
// Test Loop Count is 1 (== default) and Loop mode being set
- TestApplication application;
- Integration::Scene stage( application.GetScene() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
// LoopingMode::AUTO_REVERSE
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
DALI_TEST_CHECK(1 == animation.GetLoopCount());
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
- animation.SetLoopingMode( Animation::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
// Start the animation
animation.Play();
application.Render(0);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 0.5f * 1000.0f )/* 50% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 50% time progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// AUTO_REVERSE mode means, for Animation duration time, the actor starts from the beginning, passes the targetPosition,
// and arrives at the beginning.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 0.5f * 1000.0f )/* 100% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 100% time progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 1.0f * 1000.0f ) + 1u /*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 1.0f * 1000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
application.Render(0);
finishCheck.CheckSignalReceived();
// After all animation finished, arrives at the beginning.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
finishCheck.Reset();
}
// LoopingMode::AUTO_REVERSE in Reverse mode, which begin from the end
{
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- float durationSeconds( 1.0f );
- Animation animation = Animation::New( durationSeconds );
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
DALI_TEST_CHECK(1 == animation.GetLoopCount());
- bool signalReceived( false );
- AnimationFinishCheck finishCheck( signalReceived );
- animation.FinishedSignal().Connect( &application, finishCheck );
+ bool signalReceived(false);
+ AnimationFinishCheck finishCheck(signalReceived);
+ animation.FinishedSignal().Connect(&application, finishCheck);
application.SendNotification();
// Specify a negative multiplier to play the animation in reverse
- animation.SetSpeedFactor( -1.0f );
+ animation.SetSpeedFactor(-1.0f);
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition );
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition);
- animation.SetLoopingMode( Animation::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
// Start the animation
animation.Play();
application.Render(0);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 0.5f * 1000.0f )/* 50% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 50% time progress */);
application.SendNotification();
finishCheck.CheckSignalNotReceived();
// Setting a negative speed factor is to play the animation in reverse.
// So, when LoopingMode::AUTO_REVERSE and SetSpeedFactor( -1.0f ) is, for Animation duration time,
// the actor starts from the targetPosition, passes the beginning, and arrives at the targetPosition.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 0.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 0.5f * 1000.0f )/* 100% time progress */ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 0.5f * 1000.0f) /* 100% time progress */);
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
application.SendNotification();
- application.Render( static_cast< unsigned int >( durationSeconds * 1.0f * 1000.0f ) + 1u /*just beyond the animation duration*/ );
+ application.Render(static_cast<unsigned int>(durationSeconds * 1.0f * 1000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
application.Render(0);
finishCheck.CheckSignalReceived();
// After all animation finished, arrives at the target.
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
finishCheck.Reset();
}
Animation animation = Animation::New(1.0f);
// default mode
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::RESTART );
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::RESTART);
- animation.SetLoopingMode( Animation::AUTO_REVERSE );
- DALI_TEST_CHECK( animation.GetLoopingMode() == Animation::AUTO_REVERSE );
+ animation.SetLoopingMode(Animation::AUTO_REVERSE);
+ DALI_TEST_CHECK(animation.GetLoopingMode() == Animation::AUTO_REVERSE);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Connect to ProgressReachedSignal but do not set a required Progress marker" );
+ tet_infoline("Connect to ProgressReachedSignal but do not set a required Progress marker");
Actor actor = Actor::New();
application.GetScene().Add(actor);
AnimationFinishCheck finishCheck(finishedSignalReceived);
animation.FinishedSignal().Connect(&application, finishCheck);
- AnimationProgressCheck progressCheck( progressSignalReceived );
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ AnimationProgressCheck progressCheck(progressSignalReceived);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.Play();
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*100.0f ); // 10% progress
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 100.0f); // 10% progress
application.SendNotification();
- tet_infoline( "Ensure after animation has started playing that ProgressReachedSignal not emitted" );
+ tet_infoline("Ensure after animation has started playing that ProgressReachedSignal not emitted");
progressCheck.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*900.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 900.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
finishCheck.CheckSignalReceived();
- tet_infoline( "Animation finished" );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ tet_infoline("Animation finished");
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationMultipleProgressSignalsP(void)
{
- tet_infoline( "Multiple animations with different progress markers" );
+ tet_infoline("Multiple animations with different progress markers");
TestApplication application;
// Build the animation
Animation animationAlpha = Animation::New(0.0f);
- Animation animationBeta = Animation::New(0.0f);
+ Animation animationBeta = Animation::New(0.0f);
//Set duration
float durationSeconds(1.0f);
bool progressSignalReceivedBeta(false);
AnimationProgressCheck progressCheckAlpha(progressSignalReceivedAlpha, "animation:Alpha");
- AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta" );
+ AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta");
- DevelAnimation::ProgressReachedSignal( animationAlpha ).Connect( &application, progressCheckAlpha );
- DevelAnimation::ProgressReachedSignal( animationBeta ).Connect( &application, progressCheckBeta);
+ DevelAnimation::ProgressReachedSignal(animationAlpha).Connect(&application, progressCheckAlpha);
+ DevelAnimation::ProgressReachedSignal(animationBeta).Connect(&application, progressCheckBeta);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animationAlpha.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animationBeta.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "AnimationAlpha Progress notification set to 30%" );
- DevelAnimation::SetProgressNotification( animationAlpha, 0.3f );
+ tet_infoline("AnimationAlpha Progress notification set to 30%");
+ DevelAnimation::SetProgressNotification(animationAlpha, 0.3f);
- tet_infoline( "AnimationBeta Progress notification set to 50%" );
- DevelAnimation::SetProgressNotification( animationBeta, 0.5f );
+ tet_infoline("AnimationBeta Progress notification set to 50%");
+ DevelAnimation::SetProgressNotification(animationBeta, 0.5f);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
// Start the animations from 10% progress
- animationAlpha.SetCurrentProgress( 0.1f );
- animationBeta.SetCurrentProgress( 0.1f );
+ animationAlpha.SetCurrentProgress(0.1f);
+ animationBeta.SetCurrentProgress(0.1f);
animationAlpha.Play();
animationBeta.Play();
- tet_infoline( "Animation Playing from 10%" );
+ tet_infoline("Animation Playing from 10%");
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*100.0f ); // 20% progress
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 100.0f); // 20% progress
- tet_infoline( "Animation at 20% - No signals to be received" );
+ tet_infoline("Animation at 20% - No signals to be received");
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*200.0f ); // 40% progress
+ application.Render(durationSeconds * 200.0f); // 40% progress
application.SendNotification();
- tet_infoline( "Animation at 40% - Alpha signal should be received" );
- DALI_TEST_EQUALS( 0.4f, animationAlpha.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 40% - Alpha signal should be received");
+ DALI_TEST_EQUALS(0.4f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
progressCheckAlpha.CheckSignalReceived();
progressCheckBeta.CheckSignalNotReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
- application.Render(durationSeconds*100.0f ); // 50% progress
- tet_infoline( "Animation at 50% - Beta should receive signal, Alpha should not" );
+ application.Render(durationSeconds * 100.0f); // 50% progress
+ tet_infoline("Animation at 50% - Beta should receive signal, Alpha should not");
application.SendNotification();
- DALI_TEST_EQUALS( 0.5f, animationBeta.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.5f, animationBeta.GetCurrentProgress(), TEST_LOCATION);
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
- application.Render(static_cast<unsigned int>(durationSeconds*100.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 100.0f) /* 60% progress */);
application.SendNotification();
- tet_infoline( "Animation at 60%" );
+ tet_infoline("Animation at 60%");
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
application.SendNotification();
- tet_infoline( "Animation at 80%" );
+ tet_infoline("Animation at 80%");
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
- tet_infoline( "Animation finished" );
+ tet_infoline("Animation finished");
END_TEST;
}
int UtcDaliAnimationMultipleProgressSignalsP2(void)
{
- tet_infoline( "Multiple animations with different progress markers and big step time" );
+ tet_infoline("Multiple animations with different progress markers and big step time");
TestApplication application;
// Build the animation
Animation animationAlpha = Animation::New(0.0f);
- Animation animationBeta = Animation::New(0.0f);
+ Animation animationBeta = Animation::New(0.0f);
//Set duration
const float durationSeconds(1.0f);
bool progressSignalReceivedBeta(false);
AnimationProgressCheck progressCheckAlpha(progressSignalReceivedAlpha, "animation:Alpha");
- AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta" );
+ AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta");
- DevelAnimation::ProgressReachedSignal( animationAlpha ).Connect( &application, progressCheckAlpha );
- DevelAnimation::ProgressReachedSignal( animationBeta ).Connect( &application, progressCheckBeta);
+ DevelAnimation::ProgressReachedSignal(animationAlpha).Connect(&application, progressCheckAlpha);
+ DevelAnimation::ProgressReachedSignal(animationBeta).Connect(&application, progressCheckBeta);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animationAlpha.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animationBeta.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "AnimationAlpha Progress notification set to 1%" );
- DevelAnimation::SetProgressNotification( animationAlpha, 0.01f );
+ tet_infoline("AnimationAlpha Progress notification set to 1%");
+ DevelAnimation::SetProgressNotification(animationAlpha, 0.01f);
- tet_infoline( "AnimationBeta Progress notification set to 99%" );
- DevelAnimation::SetProgressNotification( animationBeta, 0.99f );
+ tet_infoline("AnimationBeta Progress notification set to 99%");
+ DevelAnimation::SetProgressNotification(animationBeta, 0.99f);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
// Start the animations unlimited looping
- animationAlpha.SetLooping( true );
- animationBeta.SetLooping( true );
+ animationAlpha.SetLooping(true);
+ animationBeta.SetLooping(true);
animationAlpha.Play();
animationBeta.Play();
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*20.0f ); // 2% progress
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 20.0f); // 2% progress
application.SendNotification();
- DALI_TEST_EQUALS( 0.02f, animationAlpha.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.02f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 2% - Alpha signals should be received, Beta should not." );
+ tet_infoline("Animation at 2% - Alpha signals should be received, Beta should not.");
progressCheckAlpha.CheckSignalReceived();
progressCheckBeta.CheckSignalNotReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
application.SendNotification();
- application.Render(durationSeconds*960.0f ); // 98% progress
+ application.Render(durationSeconds * 960.0f); // 98% progress
application.SendNotification();
- tet_infoline( "Animation at 98% - No signal received" );
- DALI_TEST_EQUALS( 0.98f, animationAlpha.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 98% - No signal received");
+ DALI_TEST_EQUALS(0.98f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*40.0f ); // 2% progress
+ application.Render(durationSeconds * 40.0f); // 2% progress
application.SendNotification();
- tet_infoline( "Animation loop once and now 2% - Alpha and Beta should receive signal" );
+ tet_infoline("Animation loop once and now 2% - Alpha and Beta should receive signal");
application.SendNotification();
- DALI_TEST_EQUALS( 0.02f, animationBeta.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.02f, animationBeta.GetCurrentProgress(), TEST_LOCATION);
progressCheckAlpha.CheckSignalReceived();
progressCheckBeta.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
application.SendNotification();
- application.Render(durationSeconds*980.0f ); // 100% progress
+ application.Render(durationSeconds * 980.0f); // 100% progress
application.SendNotification();
- tet_infoline( "Animation loop one more time. and now 100% - Beta should receive signal, Alhpa sholud not" );
+ tet_infoline("Animation loop one more time. and now 100% - Beta should receive signal, Alhpa sholud not");
application.SendNotification();
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
- animationAlpha.SetLooping( false );
- animationBeta.SetLooping( false );
+ animationAlpha.SetLooping(false);
+ animationBeta.SetLooping(false);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*2000.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 2000.0f) + 1u /*just beyond the animation duration*/);
application.SendNotification();
// We did expect the animation to finish
- tet_infoline( "Animation finished" );
+ tet_infoline("Animation finished");
END_TEST;
}
int UtcDaliAnimationProgressSignalWithPlayAfterP(void)
{
- tet_infoline( "Multiple animations with different progress markers" );
+ tet_infoline("Multiple animations with different progress markers");
TestApplication application;
// Build the animation
Animation animationAlpha = Animation::New(0.0f);
- Animation animationBeta = Animation::New(0.0f);
+ Animation animationBeta = Animation::New(0.0f);
//Set duration
float durationSeconds(1.0f);
bool progressSignalReceivedBeta(false);
AnimationProgressCheck progressCheckAlpha(progressSignalReceivedAlpha, "animation:Alpha");
- AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta" );
+ AnimationProgressCheck progressCheckBeta(progressSignalReceivedBeta, "animation:Beta");
- DevelAnimation::ProgressReachedSignal( animationAlpha ).Connect( &application, progressCheckAlpha );
- DevelAnimation::ProgressReachedSignal( animationBeta ).Connect( &application, progressCheckBeta);
+ DevelAnimation::ProgressReachedSignal(animationAlpha).Connect(&application, progressCheckAlpha);
+ DevelAnimation::ProgressReachedSignal(animationBeta).Connect(&application, progressCheckBeta);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animationAlpha.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
animationBeta.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "AnimationAlpha Progress notification set to 30%" );
- DevelAnimation::SetProgressNotification( animationAlpha, 0.3f );
+ tet_infoline("AnimationAlpha Progress notification set to 30%");
+ DevelAnimation::SetProgressNotification(animationAlpha, 0.3f);
- tet_infoline( "AnimationBeta Progress notification set to ~0% (==Notify when delay is done)" );
- DevelAnimation::SetProgressNotification( animationBeta, Math::MACHINE_EPSILON_1 );
+ tet_infoline("AnimationBeta Progress notification set to ~0% (==Notify when delay is done)");
+ DevelAnimation::SetProgressNotification(animationBeta, Math::MACHINE_EPSILON_1);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
animationBeta.PlayAfter(delaySeconds);
application.SendNotification();
- application.Render(0); // start animation
- application.Render(delaySeconds * 500.0f ); // 50% wait progress
+ application.Render(0); // start animation
+ application.Render(delaySeconds * 500.0f); // 50% wait progress
- tet_infoline( "Delay at 50% - No signals to be received" );
+ tet_infoline("Delay at 50% - No signals to be received");
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
application.SendNotification();
- application.Render(delaySeconds * 500.0f + durationSeconds * 50.0f ); // 100% wait, 5% progress
+ application.Render(delaySeconds * 500.0f + durationSeconds * 50.0f); // 100% wait, 5% progress
application.SendNotification();
- tet_infoline( "Delay at 100%, Animation at 5% - Beta signal should be received" );
- DALI_TEST_EQUALS( 0.05f, animationBeta.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Delay at 100%, Animation at 5% - Beta signal should be received");
+ DALI_TEST_EQUALS(0.05f, animationBeta.GetCurrentProgress(), TEST_LOCATION);
progressCheckBeta.CheckSignalReceived();
progressCheckAlpha.CheckSignalNotReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
- application.Render(durationSeconds * 200.0f ); // 25% progress
- tet_infoline( "Animation at 25% - No signals to be received" );
+ application.Render(durationSeconds * 200.0f); // 25% progress
+ tet_infoline("Animation at 25% - No signals to be received");
application.SendNotification();
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
- application.Render(durationSeconds * 200.0f ); // 45% progress
- tet_infoline( "Animation at 45% - Alpha should receive signal, Beta should not" );
+ application.Render(durationSeconds * 200.0f); // 45% progress
+ tet_infoline("Animation at 45% - Alpha should receive signal, Beta should not");
application.SendNotification();
- DALI_TEST_EQUALS( 0.45f, animationAlpha.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.45f, animationAlpha.GetCurrentProgress(), TEST_LOCATION);
progressCheckAlpha.CheckSignalReceived();
progressCheckBeta.CheckSignalNotReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheckAlpha.Reset();
progressCheckBeta.Reset();
- application.Render(static_cast<unsigned int>(durationSeconds*150.0f)/* 60% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 150.0f) /* 60% progress */);
application.SendNotification();
- tet_infoline( "Animation at 60%" );
+ tet_infoline("Animation at 60%");
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
application.SendNotification();
- tet_infoline( "Animation at 80%" );
+ tet_infoline("Animation at 80%");
progressCheckAlpha.CheckSignalNotReceived();
progressCheckBeta.CheckSignalNotReceived();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) + 1u /*just beyond the animation duration*/);
// We did expect the animation to finish
- tet_infoline( "Animation finished" );
+ tet_infoline("Animation finished");
END_TEST;
}
animation.SetDuration(durationSeconds);
// Set Looping Count
- const int loopCount( 4 );
- animation.SetLoopCount( loopCount );
+ const int loopCount(4);
+ animation.SetLoopCount(loopCount);
bool finishedSignalReceived(false);
bool progressSignalReceived(false);
animation.FinishedSignal().Connect(&application, finishCheck);
AnimationProgressCheck progressCheck(progressSignalReceived);
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "Animation Progress notification set to 50% with looping count 4" );
- DevelAnimation::SetProgressNotification( animation, 0.5f );
+ tet_infoline("Animation Progress notification set to 50% with looping count 4");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheck.CheckSignalNotReceived();
for(int count = 0; count < loopCount; count++)
{
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*0.25*1000.0f ); // 25% progress
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 25%" );
+ tet_infoline("Animation at 25%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 50% progress
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
application.SendNotification();
- tet_infoline( "Animation at 50%" );
- DALI_TEST_EQUALS( 0.5f, animation.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheck.Reset();
- application.Render(durationSeconds*0.25*1000.0f ); // 75% progress
- tet_infoline( "Animation at 75%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
- application.Render(durationSeconds*0.25*1000.0f ); // 100% progress
- tet_infoline( "Animation at 100%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
application.SendNotification();
//Nothing check at 100% progress. cause It can be both 100% and 0%.
animation.SetDuration(durationSeconds);
// Set Looping Unlmited
- animation.SetLooping( true );
+ animation.SetLooping(true);
bool finishedSignalReceived(false);
bool progressSignalReceived(false);
animation.FinishedSignal().Connect(&application, finishCheck);
AnimationProgressCheck progressCheck(progressSignalReceived);
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "Animation Progress notification set to 50% with unlimited looping" );
- DevelAnimation::SetProgressNotification( animation, 0.5f );
+ tet_infoline("Animation Progress notification set to 50% with unlimited looping");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheck.CheckSignalNotReceived();
for(int count = 0; count < 4; count++)
{
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*0.25*1000.0f ); // 25% progress
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 25%" );
+ tet_infoline("Animation at 25%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 50% progress
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
application.SendNotification();
- tet_infoline( "Animation at 50%" );
- DALI_TEST_EQUALS( 0.5f, animation.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheck.Reset();
- application.Render(durationSeconds*0.25*1000.0f ); // 75% progress
- tet_infoline( "Animation at 75%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
- application.Render(durationSeconds*0.25*1000.0f ); // 100% progress
- tet_infoline( "Animation at 100%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
application.SendNotification();
//Nothing check at 100% progress. cause It can be both 100% and 0%.
}
finishCheck.CheckSignalNotReceived();
- animation.SetLooping( false );
+ animation.SetLooping(false);
application.Render(0u);
application.SendNotification();
application.Render(static_cast<unsigned int>(durationSeconds * 1000.0f) + 10u);
animation.SetDuration(durationSeconds);
//Set speed negative
- animation.SetSpeedFactor( -1.0f );
+ animation.SetSpeedFactor(-1.0f);
// Set Looping Unlmited
- animation.SetLooping( true );
+ animation.SetLooping(true);
bool finishedSignalReceived(false);
bool progressSignalReceived(false);
animation.FinishedSignal().Connect(&application, finishCheck);
AnimationProgressCheck progressCheck(progressSignalReceived);
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "Animation Progress notification set to 50%" );
- DevelAnimation::SetProgressNotification( animation, 0.5f );
+ tet_infoline("Animation Progress notification set to 50%");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheck.CheckSignalNotReceived();
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 25% progress
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 25%" );
+ tet_infoline("Animation at 25%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 50% progress
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
application.SendNotification();
- tet_infoline( "Animation at 50%" );
- DALI_TEST_EQUALS( 0.5f, animation.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheck.Reset();
- application.Render(durationSeconds*0.25*1000.0f ); // 75% progress
- tet_infoline( "Animation at 75%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
- application.Render(durationSeconds*0.25*1000.0f ); // 100% progress
- tet_infoline( "Animation at 100%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
application.SendNotification();
//Nothing check at 100% progress. cause It can be both 100% and 0%.
finishCheck.CheckSignalNotReceived();
animation.Stop();
- animation.SetLooping( false );
- animation.SetLoopCount( 4 );
+ animation.SetLooping(false);
+ animation.SetLoopCount(4);
animation.Play();
application.Render(0u);
application.SendNotification();
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 25% progress
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 25%" );
+ tet_infoline("Animation at 25%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 50% progress
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
application.SendNotification();
- tet_infoline( "Animation at 50%" );
- DALI_TEST_EQUALS( 0.5f, animation.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheck.Reset();
- application.Render(durationSeconds*0.25*1000.0f ); // 75% progress
- tet_infoline( "Animation at 75%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
- application.Render(durationSeconds*0.25*1000.0f ); // 100% progress
- tet_infoline( "Animation at 100%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 100% progress
+ tet_infoline("Animation at 100%");
application.SendNotification();
//Nothing check at 100% progress. cause It can be both 100% and 0%.
animation.FinishedSignal().Connect(&application, finishCheck);
AnimationProgressCheck progressCheck(progressSignalReceived);
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "Animation Progress PlayRange as 10% ~ 90%" );
- animation.SetPlayRange( Vector2( 0.1f, 0.9f ) );
+ tet_infoline("Animation Progress PlayRange as 10% ~ 90%");
+ animation.SetPlayRange(Vector2(0.1f, 0.9f));
- tet_infoline( "Animation Progress notification set to >90% that never can notificated" );
- DevelAnimation::SetProgressNotification( animation, 0.9f + Math::MACHINE_EPSILON_1 );
+ tet_infoline("Animation Progress notification set to >90% that never can notificated");
+ DevelAnimation::SetProgressNotification(animation, 0.9f + Math::MACHINE_EPSILON_1);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheck.CheckSignalNotReceived();
animation.Play();
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*0.25*1000.0f ); // 35% progress
- DALI_TEST_EQUALS( 0.35f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 35% progress
+ DALI_TEST_EQUALS(0.35f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 35%" );
+ tet_infoline("Animation at 35%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 60% progress
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 60% progress
application.SendNotification();
- DALI_TEST_EQUALS( 0.6f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.6f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 60%" );
+ tet_infoline("Animation at 60%");
progressCheck.CheckSignalNotReceived();
- application.Render(durationSeconds*0.25*1000.0f ); // 85% progress
- tet_infoline( "Animation at 85%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 85% progress
+ tet_infoline("Animation at 85%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.85f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.85f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
- application.Render(durationSeconds*0.25*1000.0f ); // 90% progress
- tet_infoline( "Animation over 90%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 90% progress
+ tet_infoline("Animation over 90%");
application.SendNotification();
// progress never signaled because playrange is 90%
animation.FinishedSignal().Connect(&application, finishCheck);
AnimationProgressCheck progressCheck(progressSignalReceived);
- DevelAnimation::ProgressReachedSignal( animation ).Connect( &application, progressCheck);
+ DevelAnimation::ProgressReachedSignal(animation).Connect(&application, progressCheck);
application.SendNotification();
Vector3 targetPosition(100.0f, 100.0f, 100.0f);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
- tet_infoline( "Animation Progress notification set to 50%" );
- DevelAnimation::SetProgressNotification( animation, 0.5f );
+ tet_infoline("Animation Progress notification set to 50%");
+ DevelAnimation::SetProgressNotification(animation, 0.5f);
application.SendNotification();
- application.Render( );
+ application.Render();
progressCheck.CheckSignalNotReceived();
animation.Play();
application.SendNotification();
- application.Render(0); // start animation
- application.Render(durationSeconds*0.25*1000.0f ); // 25% progress
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
+ application.Render(0); // start animation
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 25% progress
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
- tet_infoline( "Animation at 25%" );
+ tet_infoline("Animation at 25%");
progressCheck.CheckSignalNotReceived();
application.SendNotification();
- application.Render(durationSeconds*0.25*1000.0f ); // 50% progress
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 50% progress
application.SendNotification();
- tet_infoline( "Animation at 50%" );
- DALI_TEST_EQUALS( 0.5f, animation.GetCurrentProgress(), TEST_LOCATION );
+ tet_infoline("Animation at 50%");
+ DALI_TEST_EQUALS(0.5f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalReceived();
- tet_infoline( "Progress check reset" );
+ tet_infoline("Progress check reset");
progressCheck.Reset();
- application.Render(durationSeconds*0.25*1000.0f ); // 75% progress
- tet_infoline( "Animation at 75%" );
+ application.Render(durationSeconds * 0.25 * 1000.0f); // 75% progress
+ tet_infoline("Animation at 75%");
application.SendNotification();
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
progressCheck.CheckSignalNotReceived();
Animation animation = Animation::New(1.0f);
DALI_TEST_ASSERTION(
- {
- // non animateable property (STRING)
- animation.AnimateBy( Property( actor, Actor::Property::LAYOUT_DIRECTION ), Property::Value( "new direction" ) );
- }, "Property type is not animatable" );
+ {
+ // non animateable property (STRING)
+ animation.AnimateBy(Property(actor, Actor::Property::LAYOUT_DIRECTION), Property::Value("new direction"));
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable property (MATRIX)
- Property::Index index = actor.RegisterProperty( "Foobar", Property::Value( Dali::Matrix() ), Property::ANIMATABLE );
- animation.AnimateBy( Property( actor, index ), Property::Value( Property::MATRIX ) );
- }, "Property type is not animatable" );
+ {
+ // non animateable property (MATRIX)
+ Property::Index index = actor.RegisterProperty("Foobar", Property::Value(Dali::Matrix()), Property::ANIMATABLE);
+ animation.AnimateBy(Property(actor, index), Property::Value(Property::MATRIX));
+ },
+ "Property type is not animatable");
// AnimateBy
DALI_TEST_ASSERTION(
- {
- // non animateable target (NONE)
- animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Property::Value() );
- }, "Target value is not animatable" );
+ {
+ // non animateable target (NONE)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value());
+ },
+ "Target value is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (STRING)
- animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Property::Value("foo") );
- }, "Target value is not animatable" );
+ {
+ // non animateable target (STRING)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value("foo"));
+ },
+ "Target value is not animatable");
DALI_TEST_ASSERTION(
- {
- // not mathing properties (VECTOR3, FLOAT)
- animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Property::Value( 10.f ) );
- }, "Property and target types don't match" );
+ {
+ // not mathing properties (VECTOR3, FLOAT)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value(10.f));
+ },
+ "Property and target types don't match");
DALI_TEST_ASSERTION(
- {
- // not mathing properties (VECTOR3.A, VECTOR2)
- animation.AnimateBy( Property( actor, Actor::Property::COLOR_ALPHA ), Property::Value( Property::VECTOR2 ) );
- }, "Property and target types don't match" );
+ {
+ // not mathing properties (VECTOR3.A, VECTOR2)
+ animation.AnimateBy(Property(actor, Actor::Property::COLOR_ALPHA), Property::Value(Property::VECTOR2));
+ },
+ "Property and target types don't match");
DALI_TEST_ASSERTION(
- {
- // negative duration
- animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Property::Value( Vector3(1,2,3) ), TimePeriod(-1) );
- }, "Duration must be >=0" );
+ {
+ // negative duration
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value(Vector3(1, 2, 3)), TimePeriod(-1));
+ },
+ "Duration must be >=0");
END_TEST;
}
// AnimateTo
DALI_TEST_ASSERTION(
- {
- // non animateable property (MAP)
- Property::Index index = actor.RegisterProperty( "Foobar", Property::Value( Property::MAP ), Property::ANIMATABLE );
- animation.AnimateTo( Property( actor, index ), Property::Value( Property::MAP ) );
- }, "Property type is not animatable" );
+ {
+ // non animateable property (MAP)
+ Property::Index index = actor.RegisterProperty("Foobar", Property::Value(Property::MAP), Property::ANIMATABLE);
+ animation.AnimateTo(Property(actor, index), Property::Value(Property::MAP));
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (NONE)
- animation.AnimateTo( Property( actor, Actor::Property::CLIPPING_MODE ), Property::Value() );
- }, "Property type is not animatable" );
+ {
+ // non animateable target (NONE)
+ animation.AnimateTo(Property(actor, Actor::Property::CLIPPING_MODE), Property::Value());
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (ARRAY)
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), Property::Value( Property::ARRAY ) );
- }, "Target value is not animatable" );
+ {
+ // non animateable target (ARRAY)
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Property::Value(Property::ARRAY));
+ },
+ "Target value is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (RECTANGLE)
- animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Property::Value( Rect<int32_t>() ) );
- }, "Target value is not animatable" );
+ {
+ // non animateable target (RECTANGLE)
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Property::Value(Rect<int32_t>()));
+ },
+ "Target value is not animatable");
DALI_TEST_ASSERTION(
- {
- // not mathing properties (FLOAT, INT)
- animation.AnimateTo( Property( actor, Actor::Property::SCALE_Y ), Property::Value(10) );
- }, "Property and target types don't match" );
+ {
+ // not mathing properties (FLOAT, INT)
+ animation.AnimateTo(Property(actor, Actor::Property::SCALE_Y), Property::Value(10));
+ },
+ "Property and target types don't match");
DALI_TEST_ASSERTION(
- {
- // not mathing properties (VECTOR3, VECTOR2)
- animation.AnimateTo( Property( actor, Actor::Property::COLOR ), Property::Value( Property::VECTOR2 ) );
- }, "Property and target types don't match" );
+ {
+ // not mathing properties (VECTOR3, VECTOR2)
+ animation.AnimateTo(Property(actor, Actor::Property::COLOR), Property::Value(Property::VECTOR2));
+ },
+ "Property and target types don't match");
DALI_TEST_ASSERTION(
- {
- // negative duration
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), Property::Value( Vector3(1,2,3) ), TimePeriod(-1) );
- }, "Duration must be >=0" );
+ {
+ // negative duration
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Property::Value(Vector3(1, 2, 3)), TimePeriod(-1));
+ },
+ "Duration must be >=0");
END_TEST;
}
// AnimateBetween
DALI_TEST_ASSERTION(
- {
- // non animateable property (ARRAY)
- Property::Index index = actor.RegisterProperty( "Foobar", Property::Value( Property::ARRAY ), Property::ANIMATABLE );
- KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.5f, Property::Value( Property::ARRAY ) );
- animation.AnimateBetween( Property( actor, index ), keyframes );
- }, "Property type is not animatable" );
+ {
+ // non animateable property (ARRAY)
+ Property::Index index = actor.RegisterProperty("Foobar", Property::Value(Property::ARRAY), Property::ANIMATABLE);
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Property::ARRAY));
+ animation.AnimateBetween(Property(actor, index), keyframes);
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (NONE)
- KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.5f, Property::Value() );
- animation.AnimateBetween( Property( actor, Actor::Property::CLIPPING_MODE ), keyframes );
- }, "Property type is not animatable" );
+ {
+ // non animateable target (NONE)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value());
+ animation.AnimateBetween(Property(actor, Actor::Property::CLIPPING_MODE), keyframes);
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (EXTENTS)
- KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.5f, Property::Value( Property::EXTENTS ) ); // throws
- animation.AnimateBetween( Property( actor, Actor::Property::POSITION ), keyframes );
- }, "Property type is not animatable" );
+ {
+ // non animateable target (EXTENTS)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Property::EXTENTS)); // throws
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes);
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // non animateable target (RECTANGLE)
- KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.5f, Property::Value( Property::MAP ) ); // throws
- animation.AnimateBetween( Property( actor, Actor::Property::POSITION ), keyframes );
- }, "Property type is not animatable" );
+ {
+ // non animateable target (RECTANGLE)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Property::MAP)); // throws
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes);
+ },
+ "Property type is not animatable");
DALI_TEST_ASSERTION(
- {
- // not mathing properties (VECTOR2, VECTOR4)
- KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.5f, Property::Value( Vector4( 1, 2, 3, 4 ) ) );
- animation.AnimateBetween( Property( actor, Actor::Property::MAXIMUM_SIZE ), keyframes );
- }, "Property and target types don't match" );
+ {
+ // not mathing properties (VECTOR2, VECTOR4)
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Vector4(1, 2, 3, 4)));
+ animation.AnimateBetween(Property(actor, Actor::Property::MAXIMUM_SIZE), keyframes);
+ },
+ "Property and target types don't match");
DALI_TEST_ASSERTION(
- {
- // negative duration
- KeyFrames keyframes = KeyFrames::New();
- keyframes.Add( 0.5f, Property::Value(Vector3( 1, 2, 3 ) ) );
- animation.AnimateBetween( Property( actor, Actor::Property::POSITION ), keyframes, TimePeriod(-1) );
- }, "Duration must be >=0" );
+ {
+ // negative duration
+ KeyFrames keyframes = KeyFrames::New();
+ keyframes.Add(0.5f, Property::Value(Vector3(1, 2, 3)));
+ animation.AnimateBetween(Property(actor, Actor::Property::POSITION), keyframes, TimePeriod(-1));
+ },
+ "Duration must be >=0");
END_TEST;
}
CLEAR
};
-void CheckPropertyValuesWhenCallingAnimationMethod( TestFunction functionToTest, const char * testName )
+void CheckPropertyValuesWhenCallingAnimationMethod(TestFunction functionToTest, const char* testName)
{
- tet_printf( "Testing %s\n", testName );
+ tet_printf("Testing %s\n", testName);
// When an Animation::Stop() or Animation::Clear() is called, the event-side property needs to be updated appropriately
// This test checks that that is being done
- const float durationSeconds( 1.0f );
- unsigned int halfAnimationDuration( static_cast< unsigned int >( durationSeconds * 1000.0f * 0.5f ) );
- const Vector3 originalPosition( Vector3::ZERO );
- const Vector3 targetPosition( 10.0f, 10.0f, 10.0f );
- const Vector3 halfWayToTarget( targetPosition * 0.5f );
+ const float durationSeconds(1.0f);
+ unsigned int halfAnimationDuration(static_cast<unsigned int>(durationSeconds * 1000.0f * 0.5f));
+ const Vector3 originalPosition(Vector3::ZERO);
+ const Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ const Vector3 halfWayToTarget(targetPosition * 0.5f);
struct ExpectedValue
{
Animation::EndAction endAction;
- Vector3 expectedGetPropertyValue;
+ Vector3 expectedGetPropertyValue;
};
ExpectedValue expectedValueTable[] =
- {
- { Animation::BAKE, halfWayToTarget }, // When baking, the current value is the final value.
- { Animation::BAKE_FINAL, targetPosition }, // When BakeFinal, we should jump to the final value when clearing or stopping.
- { Animation::DISCARD, originalPosition }, // When discarding, we should jump back to the original value when clearing or stopping.
- };
- const auto expectedValueTableCount = sizeof( expectedValueTable ) / sizeof( ExpectedValue );
+ {
+ {Animation::BAKE, halfWayToTarget}, // When baking, the current value is the final value.
+ {Animation::BAKE_FINAL, targetPosition}, // When BakeFinal, we should jump to the final value when clearing or stopping.
+ {Animation::DISCARD, originalPosition}, // When discarding, we should jump back to the original value when clearing or stopping.
+ };
+ const auto expectedValueTableCount = sizeof(expectedValueTable) / sizeof(ExpectedValue);
- for( auto i = 0u; i < expectedValueTableCount; ++i )
+ for(auto i = 0u; i < expectedValueTableCount; ++i)
{
TestApplication application;
application.GetScene().Add(actor);
// Build the animation
- Animation animation = Animation::New( durationSeconds );
- animation.SetEndAction( expectedValueTable[ i ].endAction );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetEndAction(expectedValueTable[i].endAction);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( halfAnimationDuration );
+ application.Render(halfAnimationDuration);
// Stop or Clear the animation early, both have the same effect
- if( functionToTest == TestFunction::STOP )
+ if(functionToTest == TestFunction::STOP)
{
animation.Stop();
}
}
// The event side property should be set the expected value immediately, the update side property will still only be halfway as we haven't run an update yet
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::POSITION ).Get< Vector3 >(), expectedValueTable[ i ].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), expectedValueTable[i].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
// After one frame, both values should match regardless of the End Action
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::POSITION ).Get< Vector3 >(), expectedValueTable[ i ].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), expectedValueTable[ i ].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), expectedValueTable[i].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), expectedValueTable[i].expectedGetPropertyValue, VECTOR3_EPSILON, TEST_LOCATION);
}
}
} // unnamed namespace
int UtcDaliAnimationStopPropertyValue(void)
{
- CheckPropertyValuesWhenCallingAnimationMethod( TestFunction::STOP, "UtcDaliAnimationStopPropertyValue" );
+ CheckPropertyValuesWhenCallingAnimationMethod(TestFunction::STOP, "UtcDaliAnimationStopPropertyValue");
END_TEST;
}
int UtcDaliAnimationClearPropertyValue(void)
{
- CheckPropertyValuesWhenCallingAnimationMethod( TestFunction::CLEAR, "UtcDaliAnimationStopPropertyValue" );
+ CheckPropertyValuesWhenCallingAnimationMethod(TestFunction::CLEAR, "UtcDaliAnimationStopPropertyValue");
END_TEST;
}
int UtcDaliAnimationPausePropertyValue(void)
{
- const float durationSeconds( 1.0f );
- unsigned int halfAnimationDuration( static_cast< unsigned int >( durationSeconds * 1000.0f * 0.5f ) );
- const Vector3 originalPosition( Vector3::ZERO );
- const Vector3 targetPosition( 10.0f, 10.0f, 10.0f );
- const Vector3 halfWayToTarget( targetPosition * 0.5f );
+ const float durationSeconds(1.0f);
+ unsigned int halfAnimationDuration(static_cast<unsigned int>(durationSeconds * 1000.0f * 0.5f));
+ const Vector3 originalPosition(Vector3::ZERO);
+ const Vector3 targetPosition(10.0f, 10.0f, 10.0f);
+ const Vector3 halfWayToTarget(targetPosition * 0.5f);
Animation::EndAction endActions[] =
- {
- Animation::BAKE,
- Animation::BAKE_FINAL,
- Animation::DISCARD,
- };
- const auto endActionCount = sizeof( endActions ) / sizeof( endActions[0] );
+ {
+ Animation::BAKE,
+ Animation::BAKE_FINAL,
+ Animation::DISCARD,
+ };
+ const auto endActionCount = sizeof(endActions) / sizeof(endActions[0]);
// For all end actions, when pausing, we stay at the current value
- for( auto i = 0u; i < endActionCount; ++i )
+ for(auto i = 0u; i < endActionCount; ++i)
{
TestApplication application;
application.GetScene().Add(actor);
// Build the animation
- Animation animation = Animation::New( durationSeconds );
- animation.SetEndAction( endActions[ i ] );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), targetPosition, AlphaFunction::LINEAR );
+ Animation animation = Animation::New(durationSeconds);
+ animation.SetEndAction(endActions[i]);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( halfAnimationDuration );
+ application.Render(halfAnimationDuration);
// Puase the animation early
animation.Pause();
// The event side property should be set the current value immediately, the update side property will still only be halfway
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::POSITION ).Get< Vector3 >(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
// After one frame, both values should match regardless of the End Action
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::POSITION ).Get< Vector3 >(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), halfWayToTarget, VECTOR3_EPSILON, TEST_LOCATION);
}
END_TEST;
TestApplication application;
auto actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- auto animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( actor, Actor::Property::POSITION_X ), 100.0f );
- animation.SetLoopCount( 2 );
+ auto animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION_X), 100.0f);
+ animation.SetLoopCount(2);
animation.Play();
application.SendNotification();
- application.Render( 1001 );
+ application.Render(1001);
// One loop completed
- application.Render( 2005 );
+ application.Render(2005);
application.SendNotification();
// 2 loops should have completed
- DALI_TEST_EQUALS( animation.GetCurrentLoop(), 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetCurrentLoop(), 2u, TEST_LOCATION);
// Another render needs to occur after all the loops end
application.SendNotification();
- application.Render( 1000 );
+ application.Render(1000);
// Stop the animation and use PlayFrom, previously we got an Assert here
animation.Stop();
- animation.PlayFrom( 0.5f );
+ animation.PlayFrom(0.5f);
application.SendNotification();
- application.Render( 1000 );
+ application.Render(1000);
- DALI_TEST_EQUALS( animation.GetState(), Animation::PLAYING, TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetState(), Animation::PLAYING, TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationCombineToAndByWithStop(void)
{
- tet_infoline( "Ensure the Y Position is not modified when animating the X position using AnimateTo and AnimateBy");
+ tet_infoline("Ensure the Y Position is not modified when animating the X position using AnimateTo and AnimateBy");
TestApplication application;
auto actor = Actor::New();
- actor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
- auto animation = Animation::New( 1.0f );
- const float origY = actor.GetProperty( Actor::Property::POSITION_Y ).Get< float >();
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), Vector3( 150.0f, origY, 0.0f ), TimePeriod( 1.0f ) );
- animation.AnimateBy( Property( actor, Actor::Property::POSITION ), Vector3( -30.0f, 0.0f, 0.0f ), TimePeriod( 1.0f, 1.0f ) );
+ auto animation = Animation::New(1.0f);
+ const float origY = actor.GetProperty(Actor::Property::POSITION_Y).Get<float>();
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(150.0f, origY, 0.0f), TimePeriod(1.0f));
+ animation.AnimateBy(Property(actor, Actor::Property::POSITION), Vector3(-30.0f, 0.0f, 0.0f), TimePeriod(1.0f, 1.0f));
animation.Play();
application.SendNotification();
- application.Render( 500 );
+ application.Render(500);
application.SendNotification();
- application.Render( 500 );
+ application.Render(500);
application.SendNotification();
- application.Render( 500 );
+ application.Render(500);
// Stop and clear the animation using the current values
animation.Stop();
animation.Clear();
// Check the y position, it should be the same as before
- DALI_TEST_EQUALS( actor.GetProperty( Actor::Property::POSITION_Y).Get< float >(), origY, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::POSITION_Y).Get<float>(), origY, TEST_LOCATION);
END_TEST;
}
int UtcDaliAnimationCountAndGetAnimationAt(void)
{
- tet_infoline( "UtcDaliAnimationCountAndGetAnimationAt");
+ tet_infoline("UtcDaliAnimationCountAndGetAnimationAt");
TestApplication application;
auto actor = Actor::New();
- actor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
- auto animation = Animation::New( 1.0f );
- const float origY = actor.GetProperty( Actor::Property::POSITION_Y ).Get< float >();
- animation.AnimateTo( Property( actor, Actor::Property::POSITION ), Vector3( 150.0f, origY, 0.0f ), TimePeriod( 1.0f ) );
+ auto animation = Animation::New(1.0f);
+ const float origY = actor.GetProperty(Actor::Property::POSITION_Y).Get<float>();
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(150.0f, origY, 0.0f), TimePeriod(1.0f));
animation.Play();
application.SendNotification();
- application.Render( 500 );
+ application.Render(500);
uint32_t animationCount = Dali::DevelAnimation::GetAnimationCount();
- DALI_TEST_EQUALS( animationCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(animationCount, 1, TEST_LOCATION);
- DALI_TEST_CHECK( !Dali::DevelAnimation::GetAnimationAt( 5 ) );
+ DALI_TEST_CHECK(!Dali::DevelAnimation::GetAnimationAt(5));
- Dali::Animation animationReturned = Dali::DevelAnimation::GetAnimationAt( 0 );
- DALI_TEST_EQUALS( animationReturned.GetState(), Dali::Animation::State::PLAYING, TEST_LOCATION );
+ Dali::Animation animationReturned = Dali::DevelAnimation::GetAnimationAt(0);
+ DALI_TEST_EQUALS(animationReturned.GetState(), Dali::Animation::State::PLAYING, TEST_LOCATION);
- DALI_TEST_EQUALS( animation.GetDuration(), animationReturned.GetDuration(), TEST_LOCATION );
- DALI_TEST_EQUALS( animation.GetLoopCount(), animationReturned.GetLoopCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( animation.IsLooping(), animationReturned.IsLooping(), TEST_LOCATION );
- DALI_TEST_EQUALS( animation.GetEndAction(), animationReturned.GetEndAction(), TEST_LOCATION );
- DALI_TEST_EQUALS( animation.GetState(), animationReturned.GetState(), TEST_LOCATION );
+ DALI_TEST_EQUALS(animation.GetDuration(), animationReturned.GetDuration(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetLoopCount(), animationReturned.GetLoopCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.IsLooping(), animationReturned.IsLooping(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetEndAction(), animationReturned.GetEndAction(), TEST_LOCATION);
+ DALI_TEST_EQUALS(animation.GetState(), animationReturned.GetState(), TEST_LOCATION);
// Stop and clear the animation using the current values
animation.Stop();
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::KeyFrames arg2;
- instance.AnimateBetween(arg1,arg2);
+ instance.AnimateBetween(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
Dali::Animation::Interpolation arg3(Animation::LINEAR);
- instance.AnimateBetween(arg1,arg2,arg3);
+ instance.AnimateBetween(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
Dali::TimePeriod arg3(1.0f);
- instance.AnimateBetween(arg1,arg2,arg3);
+ instance.AnimateBetween(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
- Dali::TimePeriod arg3(1.0f);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::TimePeriod arg3(1.0f);
Dali::Animation::Interpolation arg4(Animation::LINEAR);
- instance.AnimateBetween(arg1,arg2,arg3,arg4);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
Dali::AlphaFunction arg3;
- instance.AnimateBetween(arg1,arg2,arg3);
+ instance.AnimateBetween(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
- Dali::AlphaFunction arg3;
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
Dali::Animation::Interpolation arg4(Animation::LINEAR);
- instance.AnimateBetween(arg1,arg2,arg3,arg4);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
Dali::AlphaFunction arg3;
- Dali::TimePeriod arg4(1.0f);
- instance.AnimateBetween(arg1,arg2,arg3,arg4);
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
- Dali::KeyFrames arg2;
- Dali::AlphaFunction arg3;
- Dali::TimePeriod arg4(1.0f);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::KeyFrames arg2;
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
Dali::Animation::Interpolation arg5(Animation::LINEAR);
- instance.AnimateBetween(arg1,arg2,arg3,arg4,arg5);
+ instance.AnimateBetween(arg1, arg2, arg3, arg4, arg5);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
try
{
Dali::Actor arg1;
- float arg2(0.0f);
- instance.Hide(arg1,arg2);
+ float arg2(0.0f);
+ instance.Hide(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
try
{
Dali::Actor arg1;
- float arg2(0.0f);
- instance.Show(arg1,arg2);
+ float arg2(0.0f);
+ instance.Show(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
Dali::Animation instance;
try
{
- Dali::Actor arg1;
- Dali::Path arg2;
+ Dali::Actor arg1;
+ Dali::Path arg2;
Dali::Vector3 arg3;
- instance.Animate(arg1,arg2,arg3);
+ instance.Animate(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
Dali::Animation instance;
try
{
- Dali::Actor arg1;
- Dali::Path arg2;
- Dali::Vector3 arg3;
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
Dali::TimePeriod arg4(1.0f);
- instance.Animate(arg1,arg2,arg3,arg4);
+ instance.Animate(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
Dali::Animation instance;
try
{
- Dali::Actor arg1;
- Dali::Path arg2;
- Dali::Vector3 arg3;
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
Dali::AlphaFunction arg4;
- instance.Animate(arg1,arg2,arg3,arg4);
+ instance.Animate(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
Dali::Animation instance;
try
{
- Dali::Actor arg1;
- Dali::Path arg2;
- Dali::Vector3 arg3;
+ Dali::Actor arg1;
+ Dali::Path arg2;
+ Dali::Vector3 arg3;
Dali::AlphaFunction arg4;
- Dali::TimePeriod arg5(1.0f);
- instance.Animate(arg1,arg2,arg3,arg4,arg5);
+ Dali::TimePeriod arg5(1.0f);
+ instance.Animate(arg1, arg2, arg3, arg4, arg5);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- instance.AnimateBy(arg1,arg2);
+ instance.AnimateBy(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- Dali::TimePeriod arg3(1.0f);
- instance.AnimateBy(arg1,arg2,arg3);
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateBy(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- Dali::AlphaFunction arg3;
- instance.AnimateBy(arg1,arg2,arg3);
+ Dali::AlphaFunction arg3;
+ instance.AnimateBy(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- Dali::AlphaFunction arg3;
- Dali::TimePeriod arg4(1.0f);
- instance.AnimateBy(arg1,arg2,arg3,arg4);
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateBy(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliAnimationAnimateToNegative01(void)
{
TestApplication application;
- Dali::Actor actor;
+ Dali::Actor actor;
Dali::Animation instance;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- instance.AnimateTo(arg1,arg2);
+ instance.AnimateTo(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- Dali::TimePeriod arg3(1.0f);
- instance.AnimateTo(arg1,arg2,arg3);
+ Dali::TimePeriod arg3(1.0f);
+ instance.AnimateTo(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- Dali::AlphaFunction arg3;
- instance.AnimateTo(arg1,arg2,arg3);
+ Dali::AlphaFunction arg3;
+ instance.AnimateTo(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
{
TestApplication application;
Dali::Animation instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
- Dali::Property arg1(actor, Actor::Property::POSITION);
+ Dali::Property arg1(actor, Actor::Property::POSITION);
Dali::Property::Value arg2;
- Dali::AlphaFunction arg3;
- Dali::TimePeriod arg4(1.0f);
- instance.AnimateTo(arg1,arg2,arg3,arg4);
+ Dali::AlphaFunction arg3;
+ Dali::TimePeriod arg4(1.0f);
+ instance.AnimateTo(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
Dali::KeyFrames instance;
try
{
- float arg1(0.0f);
+ float arg1(0.0f);
Dali::Property::Value arg2;
- instance.Add(arg1,arg2);
+ instance.Add(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
Dali::KeyFrames instance;
try
{
- float arg1(0.0f);
+ float arg1(0.0f);
Dali::Property::Value arg2;
- Dali::AlphaFunction arg3;
- instance.Add(arg1,arg2,arg3);
+ Dali::AlphaFunction arg3;
+ instance.Add(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
*
*/
-#include <iostream>
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
// Temp include
#include <dali/public-api/object/any.h>
struct MyStruct
{
MyStruct()
- : mFloatValue( 0.f ),
- mIntValue( 0 )
- {}
+ : mFloatValue(0.f),
+ mIntValue(0)
+ {
+ }
- MyStruct( float fValue, int iValue )
- : mFloatValue( fValue ),
- mIntValue( iValue )
- {}
+ MyStruct(float fValue, int iValue)
+ : mFloatValue(fValue),
+ mIntValue(iValue)
+ {
+ }
- MyStruct( const MyStruct& myStruct )
- : mFloatValue( myStruct.mFloatValue ),
- mIntValue( myStruct.mIntValue )
- {}
+ MyStruct(const MyStruct& myStruct)
+ : mFloatValue(myStruct.mFloatValue),
+ mIntValue(myStruct.mIntValue)
+ {
+ }
- MyStruct& operator=( const MyStruct& myStruct )
+ MyStruct& operator=(const MyStruct& myStruct)
{
mFloatValue = myStruct.mFloatValue;
- mIntValue = myStruct.mIntValue;
+ mIntValue = myStruct.mIntValue;
return *this;
}
float mFloatValue;
- int mIntValue;
+ int mIntValue;
};
-}
+} // namespace
using namespace Dali;
// Test default constructor.
Any value;
- DALI_TEST_CHECK( typeid( void ) == value.GetType() );
+ DALI_TEST_CHECK(typeid(void) == value.GetType());
// Test constructor Any( const Type& )
Any value1 = 4u;
// Test constructor Any( const Any& ) with a non initialized Any
Any value3 = value;
- DALI_TEST_CHECK( typeid( unsigned int ) == value1.GetType() );
- DALI_TEST_CHECK( typeid( unsigned int ) == value2.GetType() );
- DALI_TEST_CHECK( typeid( void ) == value3.GetType() );
+ DALI_TEST_CHECK(typeid(unsigned int) == value1.GetType());
+ DALI_TEST_CHECK(typeid(unsigned int) == value2.GetType());
+ DALI_TEST_CHECK(typeid(void) == value3.GetType());
unsigned int uiValue1 = 0u;
unsigned int uiValue2 = 0u;
- value1.Get( uiValue1 );
- value2.Get( uiValue2 );
+ value1.Get(uiValue1);
+ value2.Get(uiValue2);
- DALI_TEST_EQUALS( uiValue1, uiValue2, TEST_LOCATION );
+ DALI_TEST_EQUALS(uiValue1, uiValue2, TEST_LOCATION);
END_TEST;
}
value1 = 4.f; // Test operator=( const Type& ) when current object is not initialized.
- value1.Get( fValue );
+ value1.Get(fValue);
- DALI_TEST_EQUALS( fValue, 4.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 4.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
value1 = 9.f; // Test operator=( const Type& ).
- value1.Get( fValue );
+ value1.Get(fValue);
- DALI_TEST_EQUALS( fValue, 9.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 9.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
Any value3 = 5.f;
value1 = value3; // Test operator=( const Any& ).
- value1.Get( fValue );
+ value1.Get(fValue);
- DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
Any value4;
value4 = value3; // Test operator=( const Any& ) when current object is not initialized.
- value4.Get( fValue );
+ value4.Get(fValue);
- DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
// Test assign a value to value3 doesn't modify value1.
value3 = 3.f;
- value1.Get( fValue );
+ value1.Get(fValue);
- DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
- value3.Get( fValue );
+ value3.Get(fValue);
- DALI_TEST_EQUALS( fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
// Test the branch when copying the same object.
- Any value5 = 3.f;
- Any& value6( value5 );
+ Any value5 = 3.f;
+ Any& value6(value5);
value6 = value5;
- value6.Get( fValue );
- DALI_TEST_EQUALS( fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ value6.Get(fValue);
+ DALI_TEST_EQUALS(fValue, 3.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
// test assignment for non-empty Any = empty Any
Any value7;
value6 = value7;
- DALI_TEST_CHECK( value6.Empty() );
-
+ DALI_TEST_CHECK(value6.Empty());
END_TEST;
}
{
value1 = value2; // Test operator=( const Any& );
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
assert = true;
}
- if( assert )
+ if(assert)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
else
{
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
}
END_TEST;
}
Any value;
- DALI_TEST_CHECK( typeid( void ) == value.GetType() );
+ DALI_TEST_CHECK(typeid(void) == value.GetType());
value = 5.f;
- DALI_TEST_CHECK( typeid( float ) == value.GetType() );
+ DALI_TEST_CHECK(typeid(float) == value.GetType());
END_TEST;
}
tet_infoline("Test Get().");
- Any value1( 5.f );
+ Any value1(5.f);
float fValue = value1.Get<float>();
- DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
fValue = 0.f;
- value1.Get( fValue );
- DALI_TEST_EQUALS( fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
+ value1.Get(fValue);
+ DALI_TEST_EQUALS(fValue, 5.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
class MyClass
{
public:
- MyClass( float fValue, int iValue )
- : mAny( MyStruct( fValue, iValue ) )
+ MyClass(float fValue, int iValue)
+ : mAny(MyStruct(fValue, iValue))
{
}
const MyStruct& Get() const
{
- return AnyCastReference<MyStruct>( mAny );
+ return AnyCastReference<MyStruct>(mAny);
}
MyStruct* GetPointer()
{
- return AnyCast<MyStruct>( &mAny );
+ return AnyCast<MyStruct>(&mAny);
}
const MyStruct* GetPointer() const
{
- return AnyCast<MyStruct>( &mAny );
+ return AnyCast<MyStruct>(&mAny);
}
private:
Dali::Any mAny;
};
- MyClass myClass( 3.25f, 3 );
+ MyClass myClass(3.25f, 3);
- MyStruct myStruct1 = myClass.Get();
+ MyStruct myStruct1 = myClass.Get();
const MyStruct& myStruct2 = myClass.Get();
- MyStruct* myStruct3 = myClass.GetPointer();
+ MyStruct* myStruct3 = myClass.GetPointer();
const MyStruct* myStruct4 = myClass.GetPointer();
- if( myStruct3 == NULL )
+ if(myStruct3 == NULL)
{
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
END_TEST;
}
- if( myStruct4 == NULL )
+ if(myStruct4 == NULL)
{
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
END_TEST;
}
- DALI_TEST_EQUALS( myStruct1.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct2.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct3->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct4->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct1.mIntValue, 3, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct2.mIntValue, 3, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct3->mIntValue, 3, TEST_LOCATION );
- DALI_TEST_EQUALS( myStruct4->mIntValue, 3, TEST_LOCATION );
+ DALI_TEST_EQUALS(myStruct1.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct2.mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct3->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct4->mFloatValue, 3.25f, Math::MACHINE_EPSILON_1000, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct1.mIntValue, 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct2.mIntValue, 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct3->mIntValue, 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(myStruct4->mIntValue, 3, TEST_LOCATION);
// Test on empty any object
Dali::Any myAny;
- float* f = myAny.GetPointer<float>();
- DALI_TEST_CHECK( f == NULL );
+ float* f = myAny.GetPointer<float>();
+ DALI_TEST_CHECK(f == NULL);
// Test on getting wrong type
myAny = 1.f;
try
{
myAny.GetPointer<int>();
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
}
END_TEST;
tet_infoline("Test Get().");
Any value1;
- Any value2( 5.f );
+ Any value2(5.f);
bool assert1 = false;
bool assert2 = false;
try
{
- uiValue = value1.Get< unsigned int >();
+ uiValue = value1.Get<unsigned int>();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
assert1 = true;
}
try
{
- uiValue = value2.Get< unsigned int >();
+ uiValue = value2.Get<unsigned int>();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
assert2 = true;
}
- if( assert1 && assert2 )
+ if(assert1 && assert2)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
else
{
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
}
- uiValue++; // supresss warning from unused variable
+ uiValue++; // supresss warning from unused variable
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
#include "dali-test-suite-utils/dali-test-suite-utils.h"
using namespace Dali;
-
void utc_base_handle_startup(void)
{
test_return_value = TET_UNDEF;
namespace
{
-
// Functor to test whether an animation finish signal is emitted
struct AnimationFinishCheck
{
void CheckSignalReceived()
{
- if (!mSignalReceived)
+ if(!mSignalReceived)
{
tet_printf("Expected Finish signal was not received\n");
tet_result(TET_FAIL);
{
// object + copy + passedByValue, ref count == 3
DALI_TEST_CHECK(passedByValue);
- if (passedByValue)
+ if(passedByValue)
{
DALI_TEST_EQUALS(3, passedByValue.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
{
};
// used for testing ThisIsSaferThanReturningVoidStar
-class FakeHandle : public BaseHandle
+class FakeHandle : public BaseHandle
{
public:
-
void RunTest()
{
return ThisIsSaferThanReturningVoidStar();
}
};
-} // anon namespace
+} // namespace
int UtcDaliBaseHandleConstructorVoid(void)
{
// Copy the object, ref count == 2
BaseHandle copy(object);
DALI_TEST_CHECK(copy);
- if (copy)
+ if(copy)
{
DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
BaseHandle anotherCopy = ImplicitCopyConstructor(copy);
DALI_TEST_CHECK(anotherCopy);
- if (anotherCopy)
+ if(anotherCopy)
{
DALI_TEST_EQUALS(3, anotherCopy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
// anotherCopy out of scope, ref count == 2
DALI_TEST_CHECK(copy);
- if (copy)
+ if(copy)
{
DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
BaseHandle object = Actor::New();
DALI_TEST_CHECK(object);
- if (object)
+ if(object)
{
DALI_TEST_EQUALS(1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
BaseHandle copy = object;
DALI_TEST_CHECK(copy);
- if (copy)
+ if(copy)
{
DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
// Initialize an object, ref count == 1
BaseHandle object = Actor::New();
- DALI_TEST_EQUALS( 1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION);
// Move the object, ref count == 1
- BaseHandle move = std::move( object );
- DALI_TEST_CHECK( move );
+ BaseHandle move = std::move(object);
+ DALI_TEST_CHECK(move);
// Check that object is moved (not copied, so ref count keeps the same)
- if ( move )
+ if(move)
{
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
- DALI_TEST_CHECK( !object );
+ DALI_TEST_CHECK(!object);
END_TEST;
}
// Initialize an object, ref count == 1
BaseHandle object = Actor::New();
- DALI_TEST_EQUALS( 1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, object.GetBaseObject().ReferenceCount(), TEST_LOCATION);
// Move the object, ref count == 1
BaseHandle move;
- move = std::move( object );
- DALI_TEST_CHECK( move );
+ move = std::move(object);
+ DALI_TEST_CHECK(move);
// Check that object is moved (not copied, so ref count keeps the same)
- if ( move )
+ if(move)
{
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
- DALI_TEST_CHECK( !object );
+ DALI_TEST_CHECK(!object);
END_TEST;
}
std::vector<Actor> myVector;
- for (int i=0; i<TargetVectorSize; ++i)
+ for(int i = 0; i < TargetVectorSize; ++i)
{
Actor actor = Actor::New();
std::stringstream stream;
- stream << "Actor " << i+1;
- actor.SetProperty( Actor::Property::NAME,stream.str());
+ stream << "Actor " << i + 1;
+ actor.SetProperty(Actor::Property::NAME, stream.str());
myVector.push_back(actor);
}
DALI_TEST_EQUALS(TargetVectorSize, static_cast<int>(myVector.size()), TEST_LOCATION);
- DALI_TEST_CHECK(myVector[0].GetProperty< std::string >( Actor::Property::NAME ) == "Actor 1");
- DALI_TEST_CHECK(myVector[1].GetProperty< std::string >( Actor::Property::NAME ) == "Actor 2");
- DALI_TEST_CHECK(myVector[2].GetProperty< std::string >( Actor::Property::NAME ) == "Actor 3");
- DALI_TEST_CHECK(myVector[3].GetProperty< std::string >( Actor::Property::NAME ) == "Actor 4");
- DALI_TEST_CHECK(myVector[4].GetProperty< std::string >( Actor::Property::NAME ) == "Actor 5");
+ DALI_TEST_CHECK(myVector[0].GetProperty<std::string>(Actor::Property::NAME) == "Actor 1");
+ DALI_TEST_CHECK(myVector[1].GetProperty<std::string>(Actor::Property::NAME) == "Actor 2");
+ DALI_TEST_CHECK(myVector[2].GetProperty<std::string>(Actor::Property::NAME) == "Actor 3");
+ DALI_TEST_CHECK(myVector[3].GetProperty<std::string>(Actor::Property::NAME) == "Actor 4");
+ DALI_TEST_CHECK(myVector[4].GetProperty<std::string>(Actor::Property::NAME) == "Actor 5");
END_TEST;
}
TestApplication application;
tet_infoline("Positive Test Dali::BaseHandle::UtcDaliBaseHandleDoAction");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
BaseHandle actorObject = actor;
DALI_TEST_CHECK(actorObject);
DALI_TEST_CHECK(actorObject.DoAction("invalidCommand", attributes) == false);
// Check that the actor is visible
- actor.SetProperty( Actor::Property::VISIBLE,true);
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
+ actor.SetProperty(Actor::Property::VISIBLE, true);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
// Check the actor performed an action to hide itself
DALI_TEST_CHECK(actorObject.DoAction("hide", attributes) == true);
application.Render();
// Check that the actor is now invisible
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == false);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == false);
// Check the actor performed an action to show itself
DALI_TEST_CHECK(actorObject.DoAction("show", attributes) == true);
application.Render();
// Check that the actor is now visible
- DALI_TEST_CHECK(actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
application.GetScene().Add(actor);
// Build an animation with initial duration of 1 second
- float durationSeconds(1.0f);
- Animation animation = Animation::New(durationSeconds);
+ float durationSeconds(1.0f);
+ Animation animation = Animation::New(durationSeconds);
BaseHandle animationObject = animation;
DALI_TEST_CHECK(animationObject);
animation.AnimateTo(Property(actor, Actor::Property::POSITION), targetPosition, AlphaFunction::LINEAR);
// Set the new duration to be 2 seconds
- float newDurationSeconds(2.0f);
- Property::Value newDurationSecondsValue = Property::Value( newDurationSeconds );
- attributes["duration"] = newDurationSecondsValue;
+ float newDurationSeconds(2.0f);
+ Property::Value newDurationSecondsValue = Property::Value(newDurationSeconds);
+ attributes["duration"] = newDurationSecondsValue;
// Check the animation performed an action to play itself with the specified duration of 2 seconds
animationObject.DoAction("play", attributes);
- bool signalReceived(false);
+ bool signalReceived(false);
AnimationFinishCheck finishCheck(signalReceived);
// use the handle API to connect the signal
- animation.ConnectSignal( &application, "finished", finishCheck );
+ animation.ConnectSignal(&application, "finished", finishCheck);
// just for coverage connect to non-existant signal as well
- animation.ConnectSignal( &application, "foo", finishCheck );
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ animation.ConnectSignal(&application, "foo", finishCheck);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
application.SendNotification();
application.Render(static_cast<uint32_t>(newDurationSeconds * 500.0f) /* half of time */);
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
// pause
animationObject.DoAction("pause", attributes);
application.SendNotification();
- application.Render(static_cast<uint32_t>(newDurationSeconds * 500.0f) + 1u/*just beyond the animation duration*/);
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ application.Render(static_cast<uint32_t>(newDurationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
// continue
animationObject.DoAction("play", attributes);
application.SendNotification();
- application.Render(static_cast<uint32_t>(newDurationSeconds * 500.0f) + 1u/*just beyond the animation duration*/);
+ application.Render(static_cast<uint32_t>(newDurationSeconds * 500.0f) + 1u /*just beyond the animation duration*/);
// We expect the animation to finish
application.SendNotification();
finishCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), targetPosition, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), targetPosition, TEST_LOCATION);
// play again
signalReceived = false;
animationObject.DoAction("stop", attributes);
application.SendNotification();
application.Render(static_cast<uint32_t>(newDurationSeconds * 1000.0f) /* full time */);
- DALI_TEST_EQUALS( signalReceived, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(signalReceived, false, TEST_LOCATION);
// Check the new animation duration is 2 seconds
DALI_TEST_EQUALS(animation.GetDuration(), newDurationSeconds, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliBaseHandleConnectSignal(void)
{
TestApplication application;
// get the root layer
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.SetProperty( Actor::Property::POSITION, Vector2( 240, 400 ));
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100, 100 ) );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.SetProperty(Actor::Property::POSITION, Vector2(240, 400));
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100, 100));
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- DALI_TEST_CHECK( gTouchCallBackCalled == false );
+ DALI_TEST_CHECK(gTouchCallBackCalled == false);
// connect to its touch signal
- actor.ConnectSignal( &application, "touched", TestCallback() );
+ actor.ConnectSignal(&application, "touched", TestCallback());
application.SendNotification();
application.Render(1000);
// simulate a touch event
Dali::Integration::Point point;
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 240, 400 ) );
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(240, 400));
Dali::Integration::TouchEvent event;
- event.AddPoint( point );
- application.ProcessEvent( event );
+ event.AddPoint(point);
+ application.ProcessEvent(event);
application.SendNotification();
application.Render(1000);
application.SendNotification();
application.Render(1000);
- DALI_TEST_CHECK( application.GetConnectionCount() > 0 );
- DALI_TEST_CHECK( gTouchCallBackCalled == true );
+ DALI_TEST_CHECK(application.GetConnectionCount() > 0);
+ DALI_TEST_CHECK(gTouchCallBackCalled == true);
gTouchCallBackCalled = false;
application.DisconnectAll();
// simulate another touch event
- application.ProcessEvent( event );
+ application.ProcessEvent(event);
- DALI_TEST_CHECK( gTouchCallBackCalled == false );
+ DALI_TEST_CHECK(gTouchCallBackCalled == false);
END_TEST;
}
std::string typeName = actor.GetTypeName();
- DALI_TEST_CHECK( typeName.size() );
- DALI_TEST_CHECK( typeName == std::string("Actor") );
+ DALI_TEST_CHECK(typeName.size());
+ DALI_TEST_CHECK(typeName == std::string("Actor"));
END_TEST;
}
int UtcDaliBaseHandleGetTypeNameN(void)
{
-
TestApplication application;
tet_infoline("Testing Dali::BaseObject::GetTypeName");
- FakeObject object;
+ FakeObject object;
std::string typeName = object.GetTypeName();
- DALI_TEST_CHECK( typeName.empty() );
+ DALI_TEST_CHECK(typeName.empty());
END_TEST;
}
tet_infoline("Testing Dali::BaseHandle::GetTypeInfo");
Dali::TypeInfo info;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
- bool ok = actor.GetTypeInfo( info );
- DALI_TEST_CHECK( ok );
+ bool ok = actor.GetTypeInfo(info);
+ DALI_TEST_CHECK(ok);
END_TEST;
}
handle.RunTest();
tet_result(TET_PASS);
END_TEST;
-
}
int UtcDaliBaseHandleGetTypeInfoN(void)
tet_infoline("Testing Dali::BaseHandle::GetTypeInfo");
Dali::TypeInfo info;
- FakeObject object;
+ FakeObject object;
- bool ok = object.GetTypeInfo( info );
- DALI_TEST_CHECK( !ok );
+ bool ok = object.GetTypeInfo(info);
+ DALI_TEST_CHECK(!ok);
END_TEST;
}
Dali::RefObject* p = actor.GetObjectPtr();
- DALI_TEST_CHECK( p != NULL );
+ DALI_TEST_CHECK(p != NULL);
END_TEST;
}
// get the root layer
BaseHandle handle = Actor::New();
- DALI_TEST_CHECK( static_cast<BaseHandle::BooleanType>( handle ) );
+ DALI_TEST_CHECK(static_cast<BaseHandle::BooleanType>(handle));
END_TEST;
}
int UtcDaliBaseHandleCompareOperatorN(void)
{
TestApplication application;
- BaseHandle handle1 = Actor::New();
- BaseHandle handle2 = handle1;
+ BaseHandle handle1 = Actor::New();
+ BaseHandle handle2 = handle1;
- DALI_TEST_CHECK( (handle1 < handle2) == false );
+ DALI_TEST_CHECK((handle1 < handle2) == false);
END_TEST;
}
int UtcDaliBaseHandleDoActionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::BaseHandle instance;
try
{
- std::string arg1;
+ std::string arg1;
Dali::Property::Map arg2;
- instance.DoAction(arg1,arg2);
+ instance.DoAction(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliBaseHandleGetTypeInfoNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::BaseHandle instance;
try
{
int UtcDaliBaseHandleGetTypeNameNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::BaseHandle instance;
try
{
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <limits>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/object/csharp-type-info.h>
#include <dali/devel-api/object/csharp-type-registry.h>
#include <dali/internal/event/common/type-registry-impl.h>
+#include <dali/public-api/dali-core.h>
#include <dali/public-api/object/property.h>
-using namespace Dali;
+#include <stdlib.h>
+#include <iostream>
+#include <limits>
+using namespace Dali;
namespace
{
-
-
static bool CreateCustomNamedInitCalled = false;
-
-BaseHandle* CreateCustomNamedInit(const char* const typeName )
+BaseHandle* CreateCustomNamedInit(const char* const typeName)
{
CreateCustomNamedInitCalled = true;
// Property Registration
bool setPropertyCalled = false;
bool getPropertyCalled = false;
-int intPropertyValue = 0;
+int intPropertyValue = 0;
-void SetProperty( BaseObject* object, const char* const propertyName , Property::Value* value )
+void SetProperty(BaseObject* object, const char* const propertyName, Property::Value* value)
{
-
- value->Get( intPropertyValue );
+ value->Get(intPropertyValue);
setPropertyCalled = true;
}
-Property::Value* GetProperty( BaseObject* object, const char* const propertyName )
+Property::Value* GetProperty(BaseObject* object, const char* const propertyName)
{
- getPropertyCalled = true;
- Property::Value* x = new Property::Value( 10 );
+ getPropertyCalled = true;
+ Property::Value* x = new Property::Value(10);
return x;
}
-}
+} // namespace
int UtcDaliRegisterCSharpTypeP(void)
{
-
TestApplication application;
- CSharpTypeRegistry::RegisterType( "CSharpControl", typeid( Dali::Actor), &CreateCustomNamedInit );
+ CSharpTypeRegistry::RegisterType("CSharpControl", typeid(Dali::Actor), &CreateCustomNamedInit);
- Dali::TypeInfo info = Dali::TypeRegistry::Get().GetTypeInfo( "CSharpControl" );
+ Dali::TypeInfo info = Dali::TypeRegistry::Get().GetTypeInfo("CSharpControl");
info.CreateInstance();
- DALI_TEST_EQUALS( CreateCustomNamedInitCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(CreateCustomNamedInitCalled, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliRegisterCSharpTypeNoInitP(void)
{
-
TestApplication application;
CreateCustomNamedInitCalled = false;
- CSharpTypeRegistry::RegisterType( "CSharpControl", typeid( Dali::Actor), &CreateCustomNamedInit );
+ CSharpTypeRegistry::RegisterType("CSharpControl", typeid(Dali::Actor), &CreateCustomNamedInit);
GetImplementation(Dali::TypeRegistry::Get()).CallInitFunctions();
- DALI_TEST_EQUALS( CreateCustomNamedInitCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(CreateCustomNamedInitCalled, false, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- CSharpTypeRegistry::RegisterType( "CSharpControl", typeid( Dali::Actor), &CreateCustomNamedInit );
+ CSharpTypeRegistry::RegisterType("CSharpControl", typeid(Dali::Actor), &CreateCustomNamedInit);
// should cause an assert because we're registering same type twice
try
{
- CSharpTypeRegistry::RegisterType( "CSharpControl", typeid( Dali::Actor), &CreateCustomNamedInit );
- tet_result( TET_FAIL );
+ CSharpTypeRegistry::RegisterType("CSharpControl", typeid(Dali::Actor), &CreateCustomNamedInit);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Duplicate type name in Type Registration", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Duplicate type name in Type Registration", TEST_LOCATION);
}
END_TEST;
int UtcDaliRegisterCSharpTypeCreateP(void)
{
-
TestApplication application;
CreateCustomNamedInitCalled = false;
- CSharpTypeRegistry::RegisterType( "CSharpControl", typeid( Dali::Actor), &CreateCustomNamedInit );
-
+ CSharpTypeRegistry::RegisterType("CSharpControl", typeid(Dali::Actor), &CreateCustomNamedInit);
- TypeInfo info = Dali::TypeRegistry::Get().GetTypeInfo( "CSharpControl");
+ TypeInfo info = Dali::TypeRegistry::Get().GetTypeInfo("CSharpControl");
BaseHandle handle = info.CreateInstance();
- DALI_TEST_EQUALS( CreateCustomNamedInitCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(CreateCustomNamedInitCalled, true, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliRegisterCSharpPropertyP(void)
{
TestApplication application;
- CSharpTypeRegistry::RegisterType( "DateControl", typeid( Dali::Actor), &CreateCustomNamedInit );
-
+ CSharpTypeRegistry::RegisterType("DateControl", typeid(Dali::Actor), &CreateCustomNamedInit);
- bool registered = CSharpTypeRegistry::RegisterProperty( "DateControl",
- "year",
- 10000 + 1,
- Property::INTEGER,
- SetProperty,
- GetProperty );
-
- DALI_TEST_EQUALS( registered, true, TEST_LOCATION );
+ bool registered = CSharpTypeRegistry::RegisterProperty("DateControl",
+ "year",
+ 10000 + 1,
+ Property::INTEGER,
+ SetProperty,
+ GetProperty);
+ DALI_TEST_EQUALS(registered, true, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRegisterCSharpPropertyN(void)
{
TestApplication application;
// register the same property twice
- CSharpTypeRegistry::RegisterType( "DateControl", typeid( Dali::Actor), &CreateCustomNamedInit );
-
-
- bool registered = CSharpTypeRegistry::RegisterProperty( "DateControl",
- "year",
- 10000 + 1,
- Property::INTEGER,
- SetProperty,
- GetProperty );
+ CSharpTypeRegistry::RegisterType("DateControl", typeid(Dali::Actor), &CreateCustomNamedInit);
- DALI_TEST_EQUALS( registered, true, TEST_LOCATION );
+ bool registered = CSharpTypeRegistry::RegisterProperty("DateControl",
+ "year",
+ 10000 + 1,
+ Property::INTEGER,
+ SetProperty,
+ GetProperty);
+ DALI_TEST_EQUALS(registered, true, TEST_LOCATION);
// should fail second time with an assert as the property is already registered
try
{
- registered = CSharpTypeRegistry::RegisterProperty( "DateControl",
- "year",
- 10000 + 1,
- Property::INTEGER,
- SetProperty,
- GetProperty );
-
- tet_result( TET_FAIL );
+ registered = CSharpTypeRegistry::RegisterProperty("DateControl",
+ "year",
+ 10000 + 1,
+ Property::INTEGER,
+ SetProperty,
+ GetProperty);
+
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property index already added to Type", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property index already added to Type", TEST_LOCATION);
}
END_TEST;
{
TestApplication application;
- // register the same property twice
- CSharpTypeRegistry::RegisterType( "DateControl", typeid( Dali::Actor), &CreateCustomNamedInit );;
-
- Property::Index index(100001);
+ // register the same property twice
+ CSharpTypeRegistry::RegisterType("DateControl", typeid(Dali::Actor), &CreateCustomNamedInit);
+ ;
- CSharpTypeRegistry::RegisterProperty( "DateControl",
- "year",
- index,
- Property::INTEGER,
- SetProperty,
- GetProperty );
+ Property::Index index(100001);
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ CSharpTypeRegistry::RegisterProperty("DateControl",
+ "year",
+ index,
+ Property::INTEGER,
+ SetProperty,
+ GetProperty);
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "DateControl" );
+ TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo("DateControl");
- // Check the property is writable in the type registry
- Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
+ // Check the property is writable in the type registry
+ Internal::TypeInfo& typeInfoImpl = GetImplementation(typeInfo);
- Property::Value value(25);
+ Property::Value value(25);
- typeInfoImpl.SetProperty( NULL, index, value );
+ typeInfoImpl.SetProperty(NULL, index, value);
- DALI_TEST_EQUALS( 25, intPropertyValue , TEST_LOCATION );
+ DALI_TEST_EQUALS(25, intPropertyValue, TEST_LOCATION);
- Property::Value value2(50);
+ Property::Value value2(50);
- typeInfoImpl.SetProperty( NULL, "year", value2 );
+ typeInfoImpl.SetProperty(NULL, "year", value2);
- DALI_TEST_EQUALS( 50, intPropertyValue , TEST_LOCATION );
+ DALI_TEST_EQUALS(50, intPropertyValue, TEST_LOCATION);
- DALI_TEST_EQUALS( setPropertyCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(setPropertyCalled, true, TEST_LOCATION);
- END_TEST;
+ END_TEST;
}
-
int UtcDaliRegisterCSharpPropertyGetP(void)
{
TestApplication application;
- // register the same property twice
- CSharpTypeRegistry::RegisterType( "DateControl", typeid( Dali::Actor), &CreateCustomNamedInit );
-
- Property::Index index(100001);
+ // register the same property twice
+ CSharpTypeRegistry::RegisterType("DateControl", typeid(Dali::Actor), &CreateCustomNamedInit);
- CSharpTypeRegistry::RegisterProperty( "DateControl",
- "year",
- index,
- Property::INTEGER,
- SetProperty,
- GetProperty );
+ Property::Index index(100001);
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ CSharpTypeRegistry::RegisterProperty("DateControl",
+ "year",
+ index,
+ Property::INTEGER,
+ SetProperty,
+ GetProperty);
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "DateControl" );
+ TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo("DateControl");
- // Check the property is writable in the type registry
- Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
+ // Check the property is writable in the type registry
+ Internal::TypeInfo& typeInfoImpl = GetImplementation(typeInfo);
- Property::Value value(1);
+ Property::Value value(1);
- value = typeInfoImpl.GetProperty( NULL, index );
+ value = typeInfoImpl.GetProperty(NULL, index);
- int propValue;
- value.Get( propValue );
+ int propValue;
+ value.Get(propValue);
- DALI_TEST_EQUALS( getPropertyCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( propValue, 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(getPropertyCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(propValue, 10, TEST_LOCATION);
- value = typeInfoImpl.GetProperty( NULL, "year");
- value.Get( propValue );
+ value = typeInfoImpl.GetProperty(NULL, "year");
+ value.Get(propValue);
- DALI_TEST_EQUALS( propValue, 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(propValue, 10, TEST_LOCATION);
- END_TEST;
+ END_TEST;
}
int UtcDaliRegisterCSharpPropertyNotRegisteredN(void)
TestApplication application;
// control not registered, should fail
- bool registered = CSharpTypeRegistry::RegisterProperty( "DateControl",
- "year",
- 10000 + 1,
- Property::INTEGER,
- SetProperty,
- GetProperty );
+ bool registered = CSharpTypeRegistry::RegisterProperty("DateControl",
+ "year",
+ 10000 + 1,
+ Property::INTEGER,
+ SetProperty,
+ GetProperty);
- DALI_TEST_EQUALS( registered, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(registered, false, TEST_LOCATION);
END_TEST;
}
-
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <cmath>
#include <dali/public-api/dali-core.h>
+
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/actors/camera-actor-devel.h>
+#include <stdlib.h>
+
+#include <cmath>
+#include <iostream>
#include "dali-test-suite-utils/dali-test-suite-utils.h"
namespace
{
-
-const float FLOAT_EPSILON = 0.001f;
-const float TEST_ASPECT_RATIO = 0.123f;
-const float TEST_FIELD_OF_VIEW = Radian(Degree(40.0f));
+const float FLOAT_EPSILON = 0.001f;
+const float TEST_ASPECT_RATIO = 0.123f;
+const float TEST_FIELD_OF_VIEW = Radian(Degree(40.0f));
const float TEST_NEAR_PLANE_DISTANCE = 0.23f;
-const float TEST_FAR_PLANE_DISTANCE = 0.973f;
+const float TEST_FAR_PLANE_DISTANCE = 0.973f;
-const std::string SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME( "uLightCameraProjectionMatrix" );
-const std::string SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME( "uLightCameraViewMatrix" );
+const std::string SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME("uLightCameraProjectionMatrix");
+const std::string SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME("uLightCameraViewMatrix");
const char* const RENDER_SHADOW_VERTEX_SOURCE =
" uniform mediump mat4 uLightCameraProjectionMatrix;\n"
" uniform mediump mat4 uLightCameraViewMatrix;\n"
struct PropertyDetails
{
- std::string name; ///< The name of the property.
- Property::Type type; ///< The property type.
- bool writable; ///< Whether the property is writable
- bool animatable; ///< Whether the property is animatable.
- bool constraintInput; ///< Whether the property can be used as an input to a constraint.
- Property::Index enumIndex; ///< Used to check the index is correct within a debug build.
+ std::string name; ///< The name of the property.
+ Property::Type type; ///< The property type.
+ bool writable; ///< Whether the property is writable
+ bool animatable; ///< Whether the property is animatable.
+ bool constraintInput; ///< Whether the property can be used as an input to a constraint.
+ Property::Index enumIndex; ///< Used to check the index is correct within a debug build.
};
} // Anonymous namespace
-
int UtcDaliCameraActorConstructorP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::CameraActor()" );
+ tet_infoline("Testing Dali::CameraActor::CameraActor()");
CameraActor actor;
- DALI_TEST_CHECK( !actor );
+ DALI_TEST_CHECK(!actor);
END_TEST;
}
int UtcDaliCameraActorDestructorP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::~CameraActor (P)" );
+ tet_infoline("Testing Dali::~CameraActor (P)");
CameraActor* actor = new CameraActor();
delete actor;
actor = NULL;
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
int UtcDaliCameraActorCopyConstructorP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Copy Constructor (P)" );
+ tet_infoline("Testing Dali::CameraActor Copy Constructor (P)");
CameraActor actor = CameraActor::New();
- CameraActor copyActor( actor );
+ CameraActor copyActor(actor);
- DALI_TEST_CHECK( copyActor );
- DALI_TEST_CHECK( copyActor == actor );
+ DALI_TEST_CHECK(copyActor);
+ DALI_TEST_CHECK(copyActor == actor);
END_TEST;
}
int UtcDaliCameraActorCopyConstructorN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Copy Constructor (N)" );
+ tet_infoline("Testing Dali::CameraActor Copy Constructor (N)");
CameraActor actor;
- CameraActor copyActor( actor );
+ CameraActor copyActor(actor);
- DALI_TEST_CHECK( !copyActor );
+ DALI_TEST_CHECK(!copyActor);
END_TEST;
}
int UtcDaliCameraActorAssignmentOperatorP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Assignment Operator (P)" );
+ tet_infoline("Testing Dali::CameraActor Assignment Operator (P)");
const CameraActor actor = CameraActor::New();
CameraActor copyActor = actor;
- DALI_TEST_CHECK( copyActor );
- DALI_TEST_CHECK( copyActor == actor );
+ DALI_TEST_CHECK(copyActor);
+ DALI_TEST_CHECK(copyActor == actor);
END_TEST;
}
int UtcDaliCameraActorAssignmentOperatorN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor = (N)" );
+ tet_infoline("Testing Dali::CameraActor = (N)");
CameraActor actor;
CameraActor copyActor = actor;
- DALI_TEST_CHECK( !copyActor );
+ DALI_TEST_CHECK(!copyActor);
END_TEST;
}
int UtcDaliCameraActorNewP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::New (P)" );
+ tet_infoline("Testing Dali::CameraActor::New (P)");
CameraActor actor = CameraActor::New();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
actor.Reset();
- DALI_TEST_CHECK( !actor );
+ DALI_TEST_CHECK(!actor);
END_TEST;
}
int UtcDaliCameraActorNewDefaultPerspectiveProjection(void)
{
TestApplication application;
- tet_infoline( "Test the perspective projection of a camera actor is set appropriately when not passing in a size" );
+ tet_infoline("Test the perspective projection of a camera actor is set appropriately when not passing in a size");
CameraActor actor = CameraActor::New();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
// All the properties should still be the default values
// Defaults taken from scene-graph-camera.cpp
- DALI_TEST_EQUALS( 4.0f/3.0f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 45.0f*(Math::PI/180.0f), actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 3.0f * 800.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 0.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(4.0f / 3.0f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(45.0f * (Math::PI / 180.0f), actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(3.0f * 800.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(0.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
// Add it to the stage, then the values should be updated to reflect a 480.0f by 800.0f scene (default stage size)
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.6f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(0.489957f, actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(4895.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
// Ensure the values stay the same after update/render
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.6f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(0.489957f, actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(4895.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorDownCastP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::DownCast (P)" );
+ tet_infoline("Testing Dali::CameraActor::DownCast (P)");
- CameraActor camera = CameraActor::New();
- Actor anActor = Actor::New();
- anActor.Add( camera );
+ CameraActor camera = CameraActor::New();
+ Actor anActor = Actor::New();
+ anActor.Add(camera);
- Actor child = anActor.GetChildAt( 0 );
- CameraActor cameraActor = CameraActor::DownCast( child );
- DALI_TEST_CHECK( cameraActor );
+ Actor child = anActor.GetChildAt(0);
+ CameraActor cameraActor = CameraActor::DownCast(child);
+ DALI_TEST_CHECK(cameraActor);
cameraActor.Reset();
- DALI_TEST_CHECK( !cameraActor );
+ DALI_TEST_CHECK(!cameraActor);
- cameraActor = DownCast< CameraActor >( child );
- DALI_TEST_CHECK( cameraActor );
+ cameraActor = DownCast<CameraActor>(child);
+ DALI_TEST_CHECK(cameraActor);
END_TEST;
}
int UtcDaliCameraActorDownCastN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::DownCast (N)" );
+ tet_infoline("Testing Dali::CameraActor::DownCast (N)");
- Actor actor1 = Actor::New();
+ Actor actor1 = Actor::New();
Actor anActor = Actor::New();
- anActor.Add( actor1 );
+ anActor.Add(actor1);
- Actor child = anActor.GetChildAt( 0 );
- CameraActor cameraActor = CameraActor::DownCast( child );
- DALI_TEST_CHECK( !cameraActor );
+ Actor child = anActor.GetChildAt(0);
+ CameraActor cameraActor = CameraActor::DownCast(child);
+ DALI_TEST_CHECK(!cameraActor);
Actor unInitialzedActor;
- cameraActor = CameraActor::DownCast( unInitialzedActor );
- DALI_TEST_CHECK( !cameraActor );
+ cameraActor = CameraActor::DownCast(unInitialzedActor);
+ DALI_TEST_CHECK(!cameraActor);
- cameraActor = DownCast< CameraActor >( unInitialzedActor );
- DALI_TEST_CHECK( !cameraActor );
+ cameraActor = DownCast<CameraActor>(unInitialzedActor);
+ DALI_TEST_CHECK(!cameraActor);
END_TEST;
}
int UtcDaliCameraActorSetGetTypeP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor GetType (P)" );
+ tet_infoline("Testing Dali::CameraActor GetType (P)");
CameraActor actor = CameraActor::New();
- DALI_TEST_EQUALS( actor.GetType(), Dali::Camera::FREE_LOOK, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetType(), Dali::Camera::FREE_LOOK, TEST_LOCATION);
- actor.SetType( Dali::Camera::LOOK_AT_TARGET );
- DALI_TEST_EQUALS( actor.GetType(), Dali::Camera::LOOK_AT_TARGET, TEST_LOCATION );
+ actor.SetType(Dali::Camera::LOOK_AT_TARGET);
+ DALI_TEST_EQUALS(actor.GetType(), Dali::Camera::LOOK_AT_TARGET, TEST_LOCATION);
- DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
- DALI_TEST_EQUALS( "LOOK_AT_TARGET", actor.GetCurrentProperty< std::string >( CameraActor::Property::TYPE ), TEST_LOCATION );
+ DALI_TEST_EQUALS("LOOK_AT_TARGET", actor.GetProperty<std::string>(CameraActor::Property::TYPE), TEST_LOCATION);
+ DALI_TEST_EQUALS("LOOK_AT_TARGET", actor.GetCurrentProperty<std::string>(CameraActor::Property::TYPE), TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetGetTypeN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor GetType (N)" );
+ tet_infoline("Testing Dali::CameraActor GetType (N)");
CameraActor actor;
{
cameraType = actor.GetType();
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera", TEST_LOCATION);
}
const CameraActor aConstActor;
{
cameraType = aConstActor.GetType();
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera", TEST_LOCATION);
}
- DALI_TEST_EQUALS( cameraType, Dali::Camera::FREE_LOOK, TEST_LOCATION );
+ DALI_TEST_EQUALS(cameraType, Dali::Camera::FREE_LOOK, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetFieldOfViewP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Field of view (P)" );
+ tet_infoline("Testing Dali::CameraActor Set Field of view (P)");
- CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
+ CameraActor defaultCamera = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
const float defaultFieldOfView = defaultCamera.GetFieldOfView();
- CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
+ CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ DALI_TEST_EQUALS(actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION);
float fieldOfView = Math::PI / 3.0f;
- actor.SetFieldOfView( fieldOfView );
- DALI_TEST_EQUALS( actor.GetFieldOfView(), fieldOfView, TEST_LOCATION );
+ actor.SetFieldOfView(fieldOfView);
+ DALI_TEST_EQUALS(actor.GetFieldOfView(), fieldOfView, TEST_LOCATION);
float value;
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetFieldOfViewN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Field of view (N)" );
+ tet_infoline("Testing Dali::CameraActor Set Field of view (N)");
- CameraActor defaultCamera = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
+ CameraActor defaultCamera = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
const float defaultFieldOfView = defaultCamera.GetFieldOfView();
- CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- DALI_TEST_EQUALS( actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION );
+ CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ DALI_TEST_EQUALS(actor.GetFieldOfView(), defaultFieldOfView, TEST_LOCATION);
float fieldOfView = Math::PI / 3.0f;
- actor.SetFieldOfView( fieldOfView );
- DALI_TEST_EQUALS( actor.GetFieldOfView(), fieldOfView, TEST_LOCATION );
+ actor.SetFieldOfView(fieldOfView);
+ DALI_TEST_EQUALS(actor.GetFieldOfView(), fieldOfView, TEST_LOCATION);
float value;
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(fieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetFieldOfViewP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Field of view (P)" );
- const Vector2 size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT );
+ tet_infoline("Testing Dali::CameraActor Get Field of view (P)");
+ const Vector2 size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT);
- CameraActor defaultCamera = CameraActor::New( size );
+ CameraActor defaultCamera = CameraActor::New(size);
- const float cameraZ = 2.0f * std::max( size.width, size.height );
- const float expectedFieldOfView = 2.0f * std::atan( size.height * 0.5f / cameraZ );
+ const float cameraZ = 2.0f * std::max(size.width, size.height);
+ const float expectedFieldOfView = 2.0f * std::atan(size.height * 0.5f / cameraZ);
- CameraActor actor = CameraActor::New( size );
- DALI_TEST_EQUALS( actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION );
+ CameraActor actor = CameraActor::New(size);
+ DALI_TEST_EQUALS(actor.GetFieldOfView(), expectedFieldOfView, TEST_LOCATION);
float value;
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( expectedFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(expectedFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetFieldOfViewN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Field of view (N)" );
+ tet_infoline("Testing Dali::CameraActor Get Field of view (N)");
CameraActor defaultCamera = CameraActor::New();
{
defaultCamera.GetFieldOfView();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetAspectRatioP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (P)" );
+ tet_infoline("Testing Dali::CameraActor Set Aspect Ratio (P)");
- CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- DALI_TEST_EQUALS( actor.GetAspectRatio(), static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT ), TEST_LOCATION );
+ CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ DALI_TEST_EQUALS(actor.GetAspectRatio(), static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH) / static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT), TEST_LOCATION);
// Set an initial value to confirm a further set changes it.
float aspect = 4.0f / 3.0f;
- actor.SetAspectRatio( aspect );
- DALI_TEST_EQUALS( actor.GetAspectRatio(), aspect, TEST_LOCATION );
+ actor.SetAspectRatio(aspect);
+ DALI_TEST_EQUALS(actor.GetAspectRatio(), aspect, TEST_LOCATION);
aspect = 16.0f / 9.0f;
- actor.SetAspectRatio( aspect );
- DALI_TEST_EQUALS( actor.GetAspectRatio(), aspect, TEST_LOCATION );
+ actor.SetAspectRatio(aspect);
+ DALI_TEST_EQUALS(actor.GetAspectRatio(), aspect, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetAspectRatioN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Aspect Ratio (N)" );
+ tet_infoline("Testing Dali::CameraActor Set Aspect Ratio (N)");
CameraActor actor;
bool asserted = true;
try
{
- actor.SetAspectRatio( 16.0f / 9.0f );
+ actor.SetAspectRatio(16.0f / 9.0f);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
TestApplication application;
tet_infoline("Testing Dali::CameraActor Get Aspect Ratio");
- CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- float defaultAspect = static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ) / static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT );
+ CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ float defaultAspect = static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH) / static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT);
- DALI_TEST_EQUALS( actor.GetAspectRatio(), defaultAspect, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetAspectRatio(), defaultAspect, TEST_LOCATION);
float value = 0.0f;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( defaultAspect, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(defaultAspect, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetAspectRatioN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Aspect Ratio (N)" );
+ tet_infoline("Testing Dali::CameraActor Get Aspect Ratio (N)");
CameraActor actor;
{
actor.GetAspectRatio();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetNearClippingPlaneP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Near clipping plane (P)" );
+ tet_infoline("Testing Dali::CameraActor Set Near clipping plane (P)");
CameraActor actor = CameraActor::New();
// Set a value so we are not relying on a particular default for this test case.
- actor.SetNearClippingPlane( 200.0f );
- DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, TEST_LOCATION );
+ actor.SetNearClippingPlane(200.0f);
+ DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 200.0f, TEST_LOCATION);
- actor.SetNearClippingPlane( 400.0f );
- DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 400.0f, TEST_LOCATION );
+ actor.SetNearClippingPlane(400.0f);
+ DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 400.0f, TEST_LOCATION);
// Check setting the property.
- actor.SetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE, Property::Value( 300.0f ) );
- DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 300.0f, FLOAT_EPSILON, TEST_LOCATION );
+ actor.SetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE, Property::Value(300.0f));
+ DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 300.0f, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetNearClippingPlaneN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Near clipping plane (N)" );
+ tet_infoline("Testing Dali::CameraActor Set Near clipping plane (N)");
CameraActor actor;
bool asserted = true;
try
{
- actor.SetNearClippingPlane( 200.0f );
+ actor.SetNearClippingPlane(200.0f);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorGetNearClippingPlaneP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Near clipping plane (P)" );
+ tet_infoline("Testing Dali::CameraActor Get Near clipping plane (P)");
// Check the default value.
- CameraActor actor = CameraActor::New();
- float defaultValue = 800.0f;
- DALI_TEST_EQUALS( actor.GetNearClippingPlane(), defaultValue, TEST_LOCATION );
+ CameraActor actor = CameraActor::New();
+ float defaultValue = 800.0f;
+ DALI_TEST_EQUALS(actor.GetNearClippingPlane(), defaultValue, TEST_LOCATION);
// Check getting the property.
float value;
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(defaultValue, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetNearClippingPlaneN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Near clipping plane (N)" );
+ tet_infoline("Testing Dali::CameraActor Get Near clipping plane (N)");
CameraActor actor;
- bool asserted = true;
+ bool asserted = true;
try
{
actor.GetNearClippingPlane();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetFarClippingPlaneP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Far clipping plane (P)" );
+ tet_infoline("Testing Dali::CameraActor Set Far clipping plane (P)");
CameraActor actor = CameraActor::New();
// Set a value so we are not relying on a particular default for this test case.
- actor.SetFarClippingPlane( 2000.0f );
- DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 2000.0f, TEST_LOCATION );
+ actor.SetFarClippingPlane(2000.0f);
+ DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 2000.0f, TEST_LOCATION);
- actor.SetFarClippingPlane( 4000.0f );
- DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 4000.0f, TEST_LOCATION );
+ actor.SetFarClippingPlane(4000.0f);
+ DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 4000.0f, TEST_LOCATION);
// Check setting the property.
- actor.SetProperty( CameraActor::Property::FAR_PLANE_DISTANCE, 2000.0f );
- DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 2000.0f, FLOAT_EPSILON, TEST_LOCATION );
+ actor.SetProperty(CameraActor::Property::FAR_PLANE_DISTANCE, 2000.0f);
+ DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 2000.0f, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetFarClippingPlaneN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Far clipping plane (N)" );
+ tet_infoline("Testing Dali::CameraActor Set Far clipping plane (N)");
CameraActor actor;
bool asserted = true;
try
{
- actor.SetFarClippingPlane( 2000.0f );
+ actor.SetFarClippingPlane(2000.0f);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorGetFarClippingPlaneP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (P)" );
+ tet_infoline("Testing Dali::CameraActor Get Far clipping plane (P)");
- CameraActor actor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- float defaultValue = 800.0f + ( 0xFFFF >> 4 );
- DALI_TEST_EQUALS( actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION );
+ CameraActor actor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ float defaultValue = 800.0f + (0xFFFF >> 4);
+ DALI_TEST_EQUALS(actor.GetFarClippingPlane(), defaultValue, TEST_LOCATION);
// Check getting the property.
float value;
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(defaultValue, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetFarClippingPlaneN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Far clipping plane (N)" );
+ tet_infoline("Testing Dali::CameraActor Get Far clipping plane (N)");
CameraActor actor;
{
actor.GetFarClippingPlane();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetTargetPositionP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Target Position (P)" );
+ tet_infoline("Testing Dali::CameraActor Set Target Position (P)");
CameraActor actor = CameraActor::New();
- Vector3 target1( 10.0f, 20.0f, 30.0f );
- Vector3 target2( 15.0f, 25.0f, 35.0f );
+ Vector3 target1(10.0f, 20.0f, 30.0f);
+ Vector3 target2(15.0f, 25.0f, 35.0f);
// Set a value so we are not relying on a particular default for this test case.
- actor.SetTargetPosition( target1 );
- DALI_TEST_EQUALS( actor.GetTargetPosition(), target1, TEST_LOCATION );
+ actor.SetTargetPosition(target1);
+ DALI_TEST_EQUALS(actor.GetTargetPosition(), target1, TEST_LOCATION);
- actor.SetTargetPosition( target2 );
- DALI_TEST_EQUALS( actor.GetTargetPosition(), target2, TEST_LOCATION );
+ actor.SetTargetPosition(target2);
+ DALI_TEST_EQUALS(actor.GetTargetPosition(), target2, TEST_LOCATION);
// Check setting the property.
- actor.SetProperty( CameraActor::Property::TARGET_POSITION, target1 );
- DALI_TEST_EQUALS( actor.GetTargetPosition(), target1, FLOAT_EPSILON, TEST_LOCATION );
+ actor.SetProperty(CameraActor::Property::TARGET_POSITION, target1);
+ DALI_TEST_EQUALS(actor.GetTargetPosition(), target1, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetTargetPositionN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set Target Position (N)" );
+ tet_infoline("Testing Dali::CameraActor Set Target Position (N)");
CameraActor actor;
bool asserted = true;
try
{
- actor.SetTargetPosition( Vector3( 10.0f, 20.0f, 30.0f ) );
+ actor.SetTargetPosition(Vector3(10.0f, 20.0f, 30.0f));
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorGetTargetPositionP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Target Position (P)" );
+ tet_infoline("Testing Dali::CameraActor Get Target Position (P)");
CameraActor actor = CameraActor::New();
- Vector3 defaultValue( Vector3::ZERO );
- DALI_TEST_EQUALS( actor.GetTargetPosition(), defaultValue, TEST_LOCATION );
+ Vector3 defaultValue(Vector3::ZERO);
+ DALI_TEST_EQUALS(actor.GetTargetPosition(), defaultValue, TEST_LOCATION);
// Check getting the property.
Vector3 value;
- actor.GetProperty( CameraActor::Property::TARGET_POSITION ).Get( value );
- DALI_TEST_EQUALS( defaultValue, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::TARGET_POSITION).Get(value);
+ DALI_TEST_EQUALS(defaultValue, value, FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetTargetPositionN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get Target Position (N)" );
+ tet_infoline("Testing Dali::CameraActor Get Target Position (N)");
CameraActor actor;
{
actor.GetTargetPosition();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetInvertYAxisP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set InvertYAxis (P)" );
+ tet_infoline("Testing Dali::CameraActor Set InvertYAxis (P)");
CameraActor actor = CameraActor::New();
// Set a value so we are not relying on a particular default for this test case.
- actor.SetInvertYAxis( false );
- DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
+ actor.SetInvertYAxis(false);
+ DALI_TEST_EQUALS(actor.GetInvertYAxis(), false, TEST_LOCATION);
- actor.SetInvertYAxis( true );
- DALI_TEST_EQUALS( actor.GetInvertYAxis(), true, TEST_LOCATION );
+ actor.SetInvertYAxis(true);
+ DALI_TEST_EQUALS(actor.GetInvertYAxis(), true, TEST_LOCATION);
- actor.SetProperty( CameraActor::Property::INVERT_Y_AXIS, false );
- DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
+ actor.SetProperty(CameraActor::Property::INVERT_Y_AXIS, false);
+ DALI_TEST_EQUALS(actor.GetInvertYAxis(), false, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetInvertYAxisN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Set InvertYAxis (N)" );
+ tet_infoline("Testing Dali::CameraActor Set InvertYAxis (N)");
CameraActor actor;
bool asserted = true;
try
{
- actor.SetInvertYAxis( false );
+ actor.SetInvertYAxis(false);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorGetInvertYAxisP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get InvertYAxis (P)" );
+ tet_infoline("Testing Dali::CameraActor Get InvertYAxis (P)");
// Check the default value.
CameraActor actor = CameraActor::New();
- DALI_TEST_EQUALS( actor.GetInvertYAxis(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetInvertYAxis(), false, TEST_LOCATION);
// Check getting the property.
bool bValue;
- actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
- DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
+ DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetInvertYAxisN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Get InvertYAxis (N)" );
+ tet_infoline("Testing Dali::CameraActor Get InvertYAxis (N)");
CameraActor actor;
{
actor.GetInvertYAxis();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetPerspectiveProjectionP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (P)" );
+ tet_infoline("Testing Dali::CameraActor::SetPerspectiveProjection (P)");
CameraActor actor = CameraActor::New();
- actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
+ actor.SetPerspectiveProjection(Size(100.f, 150.f));
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
float value;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( 0.666666f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( 0.489957f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 150.f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 4245.f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(0.666666f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(0.489957f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(150.f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(4245.f, value, FLOAT_EPSILON, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
// Ensure these values persist after adding to the stage and an update/render pass
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( 0.666666f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( 0.489957f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 150.f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 4245.f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(0.666666f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(0.489957f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(150.f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(4245.f, value, FLOAT_EPSILON, TEST_LOCATION);
// Call method with a ZERO size, this should reset the perspective projection using the size of the scene we've been added to
- actor.SetPerspectiveProjection( Vector2::ZERO );
+ actor.SetPerspectiveProjection(Vector2::ZERO);
- DALI_TEST_EQUALS( 0.6f, actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 0.489957f, actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 800.0f, actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 4895.0f, actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get< float >(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( 1600.0f, actor.GetProperty( Actor::Property::POSITION_Z ).Get< float >(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.6f, actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(0.489957f, actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(800.0f, actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(4895.0f, actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get<float>(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(1600.0f, actor.GetProperty(Actor::Property::POSITION_Z).Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetPerspectiveProjectionN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetPerspectiveProjection (N)" );
+ tet_infoline("Testing Dali::CameraActor::SetPerspectiveProjection (N)");
CameraActor actor = CameraActor::New();
// Check that setting perspective projection without a size does not do anything.
- actor.SetPerspectiveProjection( Size::ZERO );
+ actor.SetPerspectiveProjection(Size::ZERO);
// So the default values should be the same as defined in CameraActor
float nearClippingPlane = 800.0f;
- float farClippingPlane = nearClippingPlane + 2.0f * nearClippingPlane;
+ float farClippingPlane = nearClippingPlane + 2.0f * nearClippingPlane;
- DALI_TEST_EQUALS( nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(nearClippingPlane, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(farClippingPlane, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetOrthographicProjectionP1(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,1)" );
+ tet_infoline("Testing Dali::CameraActor::SetOrthographicProjection (P,1)");
- CameraActor actor = CameraActor::New( Size( 1080.0f, 1920.0f ) );
- DALI_TEST_CHECK( actor );
+ CameraActor actor = CameraActor::New(Size(1080.0f, 1920.0f));
+ DALI_TEST_CHECK(actor);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
+ actor.SetOrthographicProjection(Size(1080.0f, 1920.0f));
application.SendNotification();
- application.Render( 0 );
+ application.Render(0);
application.Render();
application.SendNotification();
float defaultFieldOfView;
float defaultNearPlaneDistance;
float defaultFarPlaneDistance;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
- Vector3 defaultPos = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(defaultAspectRatio);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(defaultFieldOfView);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(defaultNearPlaneDistance);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(defaultFarPlaneDistance);
+ Vector3 defaultPos = actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
- actor.SetOrthographicProjection( Size( 1080.0f, 1920.0f ) );
+ actor.SetOrthographicProjection(Size(1080.0f, 1920.0f));
application.SendNotification();
- application.Render( 0 );
+ application.Render(0);
application.Render();
application.SendNotification();
float value;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( defaultNearPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( defaultFarPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(defaultNearPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(defaultFarPlaneDistance, value, FLOAT_EPSILON, TEST_LOCATION);
- actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( -540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 540.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( -960.0f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(-540.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(540.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::TOP_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(960.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(-960.0f, value, FLOAT_EPSILON, TEST_LOCATION);
- Vector3 pos = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
- DALI_TEST_EQUALS( defaultPos.z, pos.z, 0.001f, TEST_LOCATION );
+ Vector3 pos = actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
+ DALI_TEST_EQUALS(defaultPos.z, pos.z, 0.001f, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetOrthographicProjectionN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (N)" );
+ tet_infoline("Testing Dali::CameraActor::SetOrthographicProjection (N)");
CameraActor actor;
- bool asserted = true;
+ bool asserted = true;
try
{
actor.GetProjectionMode();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetOrthographicProjectionP2(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,2)" );
+ tet_infoline("Testing Dali::CameraActor::SetOrthographicProjection (P,2)");
CameraActor actor = CameraActor::New();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
float defaultAspectRatio;
float defaultFieldOfView;
float defaultNearPlaneDistance;
float defaultFarPlaneDistance;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(defaultAspectRatio);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(defaultFieldOfView);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(defaultNearPlaneDistance);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(defaultFarPlaneDistance);
// Check setting with specific near and far plane distances.
- actor.SetOrthographicProjection( -100.0f, 200.0f, -300.0f, 500.0f, 400.0f, 4000.0f );
+ actor.SetOrthographicProjection(-100.0f, 200.0f, -300.0f, 500.0f, 400.0f, 4000.0f);
float value;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(400.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(4000.0f, value, FLOAT_EPSILON, TEST_LOCATION);
- actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(-100.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(200.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::TOP_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(-300.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(500.0f, value, FLOAT_EPSILON, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetOrthographicProjectionP3(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetOrthographicProjection (P,3)" );
+ tet_infoline("Testing Dali::CameraActor::SetOrthographicProjection (P,3)");
CameraActor actor = CameraActor::New();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
float defaultAspectRatio;
float defaultFieldOfView;
float defaultNearPlaneDistance;
float defaultFarPlaneDistance;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( defaultAspectRatio );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( defaultFieldOfView );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( defaultNearPlaneDistance );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( defaultFarPlaneDistance );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(defaultAspectRatio);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(defaultFieldOfView);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(defaultNearPlaneDistance);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(defaultFarPlaneDistance);
- actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
+ actor.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
- actor.SetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE, -100.0f );
- actor.SetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE, 200.0f );
- actor.SetProperty( CameraActor::Property::TOP_PLANE_DISTANCE, -300.0f );
- actor.SetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE, 500.0f );
- actor.SetNearClippingPlane( 400.0f );
- actor.SetFarClippingPlane( 4000.0f );
+ actor.SetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE, -100.0f);
+ actor.SetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE, 200.0f);
+ actor.SetProperty(CameraActor::Property::TOP_PLANE_DISTANCE, -300.0f);
+ actor.SetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE, 500.0f);
+ actor.SetNearClippingPlane(400.0f);
+ actor.SetFarClippingPlane(4000.0f);
float value;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 400.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 4000.0f, value, FLOAT_EPSILON, TEST_LOCATION );
-
- actor.GetProperty( CameraActor::Property::LEFT_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( -100.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::RIGHT_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 200.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::TOP_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( -300.0f, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::BOTTOM_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( 500.0f, value, FLOAT_EPSILON, TEST_LOCATION );
-
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(defaultAspectRatio, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(defaultFieldOfView, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(400.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(4000.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+
+ actor.GetProperty(CameraActor::Property::LEFT_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(-100.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::RIGHT_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(200.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::TOP_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(-300.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::BOTTOM_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(500.0f, value, FLOAT_EPSILON, TEST_LOCATION);
+
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
std::string stringValue;
- actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
- DALI_TEST_EQUALS( stringValue, "ORTHOGRAPHIC_PROJECTION", TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::PROJECTION_MODE).Get(stringValue);
+ DALI_TEST_EQUALS(stringValue, "ORTHOGRAPHIC_PROJECTION", TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetProjectionModeP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (P)" );
+ tet_infoline("Testing Dali::CameraActor::SetProjectionModeP (P)");
CameraActor actor = CameraActor::New();
// Check that changing the projection mode alone does not alter other presets.
- actor.SetNearClippingPlane( 200.0f );
- actor.SetFarClippingPlane( 400.0f );
+ actor.SetNearClippingPlane(200.0f);
+ actor.SetFarClippingPlane(400.0f);
- actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
+ actor.SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION);
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION);
- actor.SetProjectionMode( Dali::Camera::ORTHOGRAPHIC_PROJECTION );
+ actor.SetProjectionMode(Dali::Camera::ORTHOGRAPHIC_PROJECTION);
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetNearClippingPlane(), 200.0f, FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetFarClippingPlane(), 400.0f, FLOAT_EPSILON, TEST_LOCATION);
// Check setting the property.
Property::Value setValue = "PERSPECTIVE_PROJECTION";
- actor.SetProperty( CameraActor::Property::PROJECTION_MODE, setValue );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ actor.SetProperty(CameraActor::Property::PROJECTION_MODE, setValue);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetProjectionModeN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetProjectionModeP (N)" );
+ tet_infoline("Testing Dali::CameraActor::SetProjectionModeP (N)");
CameraActor actor;
bool asserted = true;
try
{
- actor.SetProjectionMode( Dali::Camera::PERSPECTIVE_PROJECTION );
+ actor.SetProjectionMode(Dali::Camera::PERSPECTIVE_PROJECTION);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorGetProjectionModeP(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::GetPerspectiveProjection (P)" );
+ tet_infoline("Testing Dali::CameraActor::GetPerspectiveProjection (P)");
CameraActor actor = CameraActor::New();
- actor.SetOrthographicProjection( Size::ONE );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION );
+ actor.SetOrthographicProjection(Size::ONE);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::ORTHOGRAPHIC_PROJECTION, TEST_LOCATION);
- actor.SetPerspectiveProjection( Size( 100.f, 150.f ) );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
+ actor.SetPerspectiveProjection(Size(100.f, 150.f));
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
// Check getting the property.
std::string stringValue;
- actor.GetProperty( CameraActor::Property::PROJECTION_MODE ).Get( stringValue );
- DALI_TEST_EQUALS( stringValue, "PERSPECTIVE_PROJECTION", TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::PROJECTION_MODE).Get(stringValue);
+ DALI_TEST_EQUALS(stringValue, "PERSPECTIVE_PROJECTION", TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetProjectionModeN(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::GetProjectionMode (N)" );
+ tet_infoline("Testing Dali::CameraActor::GetProjectionMode (N)");
CameraActor actor;
{
actor.GetProjectionMode();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "camera && \"Camera handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "camera && \"Camera handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliCameraActorSetCameraOffScene(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
+ tet_infoline("Testing Dali::CameraActor::SetCamera()");
CameraActor actor = CameraActor::New();
- actor.SetType( Camera::FREE_LOOK );
- actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
- actor.SetAspectRatio( TEST_ASPECT_RATIO );
- actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
- actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
- actor.SetProjectionMode( Camera::PERSPECTIVE_PROJECTION );
+ actor.SetType(Camera::FREE_LOOK);
+ actor.SetFieldOfView(TEST_FIELD_OF_VIEW);
+ actor.SetAspectRatio(TEST_ASPECT_RATIO);
+ actor.SetNearClippingPlane(TEST_NEAR_PLANE_DISTANCE);
+ actor.SetFarClippingPlane(TEST_FAR_PLANE_DISTANCE);
+ actor.SetProjectionMode(Camera::PERSPECTIVE_PROJECTION);
- actor.SetInvertYAxis( false );
+ actor.SetInvertYAxis(false);
- DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );//change to machine epsilon
- DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( Camera::PERSPECTIVE_PROJECTION, actor.GetProjectionMode(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
+ DALI_TEST_EQUALS(TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION); //change to machine epsilon
+ DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(Camera::PERSPECTIVE_PROJECTION, actor.GetProjectionMode(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
- float value;
+ float value;
std::string sValue;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO).Get( value );
- DALI_TEST_EQUALS( TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW).Get( value );
- DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE).Get( value );
- DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE).Get( value );
- DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::PROJECTION_MODE).Get( sValue );
- DALI_TEST_EQUALS( "PERSPECTIVE_PROJECTION", sValue, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::PROJECTION_MODE).Get(sValue);
+ DALI_TEST_EQUALS("PERSPECTIVE_PROJECTION", sValue, TEST_LOCATION);
bool bValue;
- actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS).Get( bValue );
- DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
+ DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorSetCameraOnScene(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::SetCamera()" );
+ tet_infoline("Testing Dali::CameraActor::SetCamera()");
CameraActor actor = CameraActor::New();
- application.GetScene().Add( actor );
- application.Render( 0 );
+ application.GetScene().Add(actor);
+ application.Render(0);
application.SendNotification();
- actor.SetType( Camera::LOOK_AT_TARGET );
- actor.SetFieldOfView( TEST_FIELD_OF_VIEW );
- actor.SetAspectRatio( TEST_ASPECT_RATIO );
- actor.SetNearClippingPlane( TEST_NEAR_PLANE_DISTANCE );
- actor.SetFarClippingPlane( TEST_FAR_PLANE_DISTANCE );
- actor.SetInvertYAxis( false );
+ actor.SetType(Camera::LOOK_AT_TARGET);
+ actor.SetFieldOfView(TEST_FIELD_OF_VIEW);
+ actor.SetAspectRatio(TEST_ASPECT_RATIO);
+ actor.SetNearClippingPlane(TEST_NEAR_PLANE_DISTANCE);
+ actor.SetFarClippingPlane(TEST_FAR_PLANE_DISTANCE);
+ actor.SetInvertYAxis(false);
- DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
+ DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
// Will need 2 frames to ensure both buffers are set to same values:
application.Render();
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( false, actor.GetInvertYAxis(), TEST_LOCATION );
+ DALI_TEST_EQUALS(TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, actor.GetInvertYAxis(), TEST_LOCATION);
std::string sValue;
- actor.GetProperty( CameraActor::Property::TYPE ).Get( sValue );
- DALI_TEST_EQUALS( sValue, "LOOK_AT_TARGET", TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::TYPE).Get(sValue);
+ DALI_TEST_EQUALS(sValue, "LOOK_AT_TARGET", TEST_LOCATION);
float value;
- actor.GetProperty( CameraActor::Property::ASPECT_RATIO ).Get( value );
- DALI_TEST_EQUALS( TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FIELD_OF_VIEW ).Get( value );
- DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE ).Get( value );
- DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
- actor.GetProperty( CameraActor::Property::FAR_PLANE_DISTANCE ).Get( value);
- DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::ASPECT_RATIO).Get(value);
+ DALI_TEST_EQUALS(TEST_ASPECT_RATIO, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FIELD_OF_VIEW).Get(value);
+ DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
+ actor.GetProperty(CameraActor::Property::FAR_PLANE_DISTANCE).Get(value);
+ DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, value, FLOAT_EPSILON, TEST_LOCATION);
bool bValue;
- actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
- DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
+ actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
+ DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetCamera(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::GetCamera()" );
+ tet_infoline("Testing Dali::CameraActor::GetCamera()");
CameraActor actor = CameraActor::New();
- actor.SetAspectRatio( TEST_ASPECT_RATIO );
+ actor.SetAspectRatio(TEST_ASPECT_RATIO);
- DALI_TEST_EQUALS( actor.GetAspectRatio(), TEST_ASPECT_RATIO, FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetAspectRatio(), TEST_ASPECT_RATIO, FLOAT_EPSILON, TEST_LOCATION);
- actor.SetProperty( CameraActor::Property::TYPE, "FREE_LOOK" );
- actor.SetProperty( CameraActor::Property::ASPECT_RATIO, TEST_ASPECT_RATIO );
- actor.SetProperty( CameraActor::Property::FIELD_OF_VIEW, TEST_FIELD_OF_VIEW );
- actor.SetProperty( CameraActor::Property::NEAR_PLANE_DISTANCE, TEST_NEAR_PLANE_DISTANCE );
- actor.SetProperty( CameraActor::Property::FAR_PLANE_DISTANCE, TEST_FAR_PLANE_DISTANCE );
+ actor.SetProperty(CameraActor::Property::TYPE, "FREE_LOOK");
+ actor.SetProperty(CameraActor::Property::ASPECT_RATIO, TEST_ASPECT_RATIO);
+ actor.SetProperty(CameraActor::Property::FIELD_OF_VIEW, TEST_FIELD_OF_VIEW);
+ actor.SetProperty(CameraActor::Property::NEAR_PLANE_DISTANCE, TEST_NEAR_PLANE_DISTANCE);
+ actor.SetProperty(CameraActor::Property::FAR_PLANE_DISTANCE, TEST_FAR_PLANE_DISTANCE);
- DALI_TEST_EQUALS( Camera::FREE_LOOK, actor.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
- DALI_TEST_EQUALS( TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION );
+ DALI_TEST_EQUALS(Camera::FREE_LOOK, actor.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_ASPECT_RATIO, actor.GetAspectRatio(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_FIELD_OF_VIEW, actor.GetFieldOfView(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_NEAR_PLANE_DISTANCE, actor.GetNearClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
+ DALI_TEST_EQUALS(TEST_FAR_PLANE_DISTANCE, actor.GetFarClippingPlane(), FLOAT_EPSILON, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorDefaultProperties(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor DefaultProperties" );
+ tet_infoline("Testing Dali::CameraActor DefaultProperties");
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New();
Integration::Scene stage = application.GetScene();
stage.Add(actor);
- stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
+ stage.GetRenderTaskList().GetTask(0).SetCameraActor(actor);
- actor.SetAspectRatio( TEST_ASPECT_RATIO );
- application.GetScene().Add( actor );
- application.Render( 0 );
+ actor.SetAspectRatio(TEST_ASPECT_RATIO);
+ application.GetScene().Add(actor);
+ application.Render(0);
application.SendNotification();
bool bValue;
- actor.GetProperty( CameraActor::Property::INVERT_Y_AXIS ).Get( bValue );
- DALI_TEST_EQUALS( false, bValue, TEST_LOCATION );
-
- std::vector<Property::Index> indices ;
- indices.push_back( CameraActor::Property::TYPE );
- indices.push_back( CameraActor::Property::PROJECTION_MODE );
- indices.push_back( CameraActor::Property::FIELD_OF_VIEW );
- indices.push_back( CameraActor::Property::ASPECT_RATIO );
- indices.push_back( CameraActor::Property::NEAR_PLANE_DISTANCE );
- indices.push_back( CameraActor::Property::FAR_PLANE_DISTANCE );
- indices.push_back( CameraActor::Property::LEFT_PLANE_DISTANCE );
- indices.push_back( CameraActor::Property::RIGHT_PLANE_DISTANCE );
- indices.push_back( CameraActor::Property::TOP_PLANE_DISTANCE );
- indices.push_back( CameraActor::Property::BOTTOM_PLANE_DISTANCE );
- indices.push_back( CameraActor::Property::TARGET_POSITION );
- indices.push_back( CameraActor::Property::PROJECTION_MATRIX );
- indices.push_back( CameraActor::Property::VIEW_MATRIX );
- indices.push_back( CameraActor::Property::INVERT_Y_AXIS );
-
- DALI_TEST_CHECK( actor.GetPropertyCount() == ( Actor::New().GetPropertyCount() + indices.size() ) );
-
- for( std::vector<Property::Index>::iterator iter = indices.begin(); iter != indices.end(); ++iter )
- {
- DALI_TEST_EQUALS( *iter, actor.GetPropertyIndex( actor.GetPropertyName( *iter ) ), TEST_LOCATION);
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( *iter ) );
-
- if ( ( *iter == CameraActor::Property::PROJECTION_MATRIX ) ||
- ( *iter == CameraActor::Property::VIEW_MATRIX ) )
+ actor.GetProperty(CameraActor::Property::INVERT_Y_AXIS).Get(bValue);
+ DALI_TEST_EQUALS(false, bValue, TEST_LOCATION);
+
+ std::vector<Property::Index> indices;
+ indices.push_back(CameraActor::Property::TYPE);
+ indices.push_back(CameraActor::Property::PROJECTION_MODE);
+ indices.push_back(CameraActor::Property::FIELD_OF_VIEW);
+ indices.push_back(CameraActor::Property::ASPECT_RATIO);
+ indices.push_back(CameraActor::Property::NEAR_PLANE_DISTANCE);
+ indices.push_back(CameraActor::Property::FAR_PLANE_DISTANCE);
+ indices.push_back(CameraActor::Property::LEFT_PLANE_DISTANCE);
+ indices.push_back(CameraActor::Property::RIGHT_PLANE_DISTANCE);
+ indices.push_back(CameraActor::Property::TOP_PLANE_DISTANCE);
+ indices.push_back(CameraActor::Property::BOTTOM_PLANE_DISTANCE);
+ indices.push_back(CameraActor::Property::TARGET_POSITION);
+ indices.push_back(CameraActor::Property::PROJECTION_MATRIX);
+ indices.push_back(CameraActor::Property::VIEW_MATRIX);
+ indices.push_back(CameraActor::Property::INVERT_Y_AXIS);
+
+ DALI_TEST_CHECK(actor.GetPropertyCount() == (Actor::New().GetPropertyCount() + indices.size()));
+
+ for(std::vector<Property::Index>::iterator iter = indices.begin(); iter != indices.end(); ++iter)
+ {
+ DALI_TEST_EQUALS(*iter, actor.GetPropertyIndex(actor.GetPropertyName(*iter)), TEST_LOCATION);
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(*iter));
+
+ if((*iter == CameraActor::Property::PROJECTION_MATRIX) ||
+ (*iter == CameraActor::Property::VIEW_MATRIX))
{
- DALI_TEST_CHECK( !actor.IsPropertyWritable( *iter ) );
+ DALI_TEST_CHECK(!actor.IsPropertyWritable(*iter));
}
else
{
- DALI_TEST_CHECK( actor.IsPropertyWritable( *iter ) );
+ DALI_TEST_CHECK(actor.IsPropertyWritable(*iter));
}
- DALI_TEST_CHECK( actor.GetPropertyType( *iter ) == actor.GetPropertyType( *iter ) ); // just checking call succeeds
+ DALI_TEST_CHECK(actor.GetPropertyType(*iter) == actor.GetPropertyType(*iter)); // just checking call succeeds
}
// Set/Get one of them.
const float newAspect = TEST_ASPECT_RATIO * 2.0f;
- actor.SetProperty( CameraActor::Property::ASPECT_RATIO, Property::Value( newAspect ) );
+ actor.SetProperty(CameraActor::Property::ASPECT_RATIO, Property::Value(newAspect));
application.Render();
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetAspectRatio(), newAspect, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetAspectRatio(), newAspect, TEST_LOCATION);
END_TEST;
}
-template< typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-void TEST_CAMERA_PROPERTY( P1 camera, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION )
+template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
+void TEST_CAMERA_PROPERTY(P1 camera, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION)
{
- DALI_TEST_EQUALS( camera.GetPropertyName( enumName ), stringName, LOCATION );
- DALI_TEST_EQUALS( camera.GetPropertyIndex( stringName ), static_cast<Property::Index>(enumName), LOCATION );
- DALI_TEST_EQUALS( camera.GetPropertyType( enumName ), type, LOCATION );
- DALI_TEST_EQUALS( camera.IsPropertyWritable( enumName ), isWriteable, LOCATION );
- DALI_TEST_EQUALS( camera.IsPropertyAnimatable( enumName ), isAnimateable, LOCATION );
- DALI_TEST_EQUALS( camera.IsPropertyAConstraintInput( enumName ), isConstraintInput, LOCATION );
+ DALI_TEST_EQUALS(camera.GetPropertyName(enumName), stringName, LOCATION);
+ DALI_TEST_EQUALS(camera.GetPropertyIndex(stringName), static_cast<Property::Index>(enumName), LOCATION);
+ DALI_TEST_EQUALS(camera.GetPropertyType(enumName), type, LOCATION);
+ DALI_TEST_EQUALS(camera.IsPropertyWritable(enumName), isWriteable, LOCATION);
+ DALI_TEST_EQUALS(camera.IsPropertyAnimatable(enumName), isAnimateable, LOCATION);
+ DALI_TEST_EQUALS(camera.IsPropertyAConstraintInput(enumName), isConstraintInput, LOCATION);
}
int UtcDaliCameraActorDefaultPropertiesInherited(void)
{
TestApplication application;
- CameraActor actor = CameraActor::New();
+ CameraActor actor = CameraActor::New();
Integration::Scene stage = application.GetScene();
stage.Add(actor);
- stage.GetRenderTaskList().GetTask(0).SetCameraActor( actor );
+ stage.GetRenderTaskList().GetTask(0).SetCameraActor(actor);
- application.GetScene().Add( actor );
- application.Render( 0 );
+ application.GetScene().Add(actor);
+ application.Render(0);
application.SendNotification();
const PropertyDetails CAMERA_DEFAULT_PROPERTY[] =
- {
-// actor
- { "parentOrigin", Property::VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN },
- { "parentOriginX", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X },
- { "parentOriginY", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y },
- { "parentOriginZ", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z },
- { "anchorPoint", Property::VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT },
- { "anchorPointX", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X },
- { "anchorPointY", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y },
- { "anchorPointZ", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z },
- { "size", Property::VECTOR3, true, true, true, Dali::Actor::Property::SIZE },
- { "sizeWidth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH },
- { "sizeHeight", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT },
- { "sizeDepth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH },
- { "position", Property::VECTOR3, true, true, true, Dali::Actor::Property::POSITION },
- { "positionX", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_X },
- { "positionY", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y },
- { "positionZ", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z },
- { "worldPosition", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION },
- { "worldPositionX", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X },
- { "worldPositionY", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y },
- { "worldPositionZ", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z },
- { "orientation", Property::ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION },
- { "worldOrientation", Property::ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION },
- { "scale", Property::VECTOR3, true, true, true, Dali::Actor::Property::SCALE },
- { "scaleX", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_X },
- { "scaleY", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y },
- { "scaleZ", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z },
- { "worldScale", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE },
- { "visible", Property::BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE },
- { "color", Property::VECTOR4, true, true, true, Dali::Actor::Property::COLOR },
- { "colorRed", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED },
- { "colorGreen", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN },
- { "colorBlue", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE },
- { "colorAlpha", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA },
- { "worldColor", Property::VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR },
- { "worldMatrix", Property::MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX },
- { "name", Property::STRING, true, false, false, Dali::Actor::Property::NAME },
- { "sensitive", Property::BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE },
- { "leaveRequired", Property::BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED },
- { "inheritOrientation", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION },
- { "inheritScale", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE },
- { "colorMode", Property::INTEGER, true, false, false, Dali::Actor::Property::COLOR_MODE },
- { "drawMode", Property::INTEGER, true, false, false, Dali::Actor::Property::DRAW_MODE },
- { "sizeModeFactor", Property::VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR },
- { "widthResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY },
- { "heightResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY },
- { "sizeScalePolicy", Property::INTEGER, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY },
- { "widthForHeight", Property::BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT },
- { "heightForWidth", Property::BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH },
- { "padding", Property::VECTOR4, true, false, false, Dali::Actor::Property::PADDING },
- { "minimumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE },
- { "maximumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE },
- { "inheritPosition", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION },
- { "clippingMode", Property::STRING, true, false, false, Dali::Actor::Property::CLIPPING_MODE },
- { "layoutDirection", Property::STRING, true, false, false, Dali::Actor::Property::LAYOUT_DIRECTION },
- { "inheritLayoutDirection", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION },
- { "opacity", Property::FLOAT, true, true, true, Dali::Actor::Property::OPACITY },
- { "screenPosition", Property::VECTOR2, false, false, false, Dali::Actor::Property::SCREEN_POSITION },
- { "positionUsesAnchorPoint",Property::BOOLEAN, true, false, false, Dali::Actor::Property::POSITION_USES_ANCHOR_POINT },
- { "culled", Property::BOOLEAN, false, false, true, Dali::Actor::Property::CULLED },
- { "id", Property::INTEGER, false, false, false, Dali::Actor::Property::ID },
- { "hierarchyDepth", Property::INTEGER, false, false, false, Dali::Actor::Property::HIERARCHY_DEPTH },
- { "isRoot", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_ROOT },
- { "isLayer", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_LAYER },
- { "connectedToScene", Property::BOOLEAN, false, false, false, Dali::Actor::Property::CONNECTED_TO_SCENE },
- { "keyboardFocusable", Property::BOOLEAN, true, false, false, Dali::Actor::Property::KEYBOARD_FOCUSABLE },
- { "siblingOrder", Property::INTEGER, true, false, false, Dali::DevelActor::Property::SIBLING_ORDER },
-// camera own
- { "type", Property::STRING, true, false, true, Dali::CameraActor::Property::TYPE },
- { "projectionMode", Property::STRING, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE },
- { "fieldOfView", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FIELD_OF_VIEW },
- { "aspectRatio", Property::FLOAT, true, false, true, Dali::CameraActor::Property::ASPECT_RATIO },
- { "nearPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE },
- { "farPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE },
- { "leftPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE },
- { "rightPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE },
- { "topPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE },
- { "bottomPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE },
- { "targetPosition", Property::VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION },
- { "projectionMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX },
- { "viewMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX },
- { "invertYAxis", Property::BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS }
- };
-
- for( uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY)/sizeof(PropertyDetails)); ++index )
- {
- TEST_CAMERA_PROPERTY( actor,
- CAMERA_DEFAULT_PROPERTY[ index ].name,
- CAMERA_DEFAULT_PROPERTY[ index ].type,
- CAMERA_DEFAULT_PROPERTY[ index ].writable,
- CAMERA_DEFAULT_PROPERTY[ index ].animatable,
- CAMERA_DEFAULT_PROPERTY[ index ].constraintInput,
- CAMERA_DEFAULT_PROPERTY[ index ].enumIndex,
- TEST_LOCATION );
+ {
+ // actor
+ {"parentOrigin", Property::VECTOR3, true, false, true, Dali::Actor::Property::PARENT_ORIGIN},
+ {"parentOriginX", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_X},
+ {"parentOriginY", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Y},
+ {"parentOriginZ", Property::FLOAT, true, false, true, Dali::Actor::Property::PARENT_ORIGIN_Z},
+ {"anchorPoint", Property::VECTOR3, true, false, true, Dali::Actor::Property::ANCHOR_POINT},
+ {"anchorPointX", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_X},
+ {"anchorPointY", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Y},
+ {"anchorPointZ", Property::FLOAT, true, false, true, Dali::Actor::Property::ANCHOR_POINT_Z},
+ {"size", Property::VECTOR3, true, true, true, Dali::Actor::Property::SIZE},
+ {"sizeWidth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_WIDTH},
+ {"sizeHeight", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_HEIGHT},
+ {"sizeDepth", Property::FLOAT, true, true, true, Dali::Actor::Property::SIZE_DEPTH},
+ {"position", Property::VECTOR3, true, true, true, Dali::Actor::Property::POSITION},
+ {"positionX", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_X},
+ {"positionY", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Y},
+ {"positionZ", Property::FLOAT, true, true, true, Dali::Actor::Property::POSITION_Z},
+ {"worldPosition", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_POSITION},
+ {"worldPositionX", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_X},
+ {"worldPositionY", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Y},
+ {"worldPositionZ", Property::FLOAT, false, false, true, Dali::Actor::Property::WORLD_POSITION_Z},
+ {"orientation", Property::ROTATION, true, true, true, Dali::Actor::Property::ORIENTATION},
+ {"worldOrientation", Property::ROTATION, false, false, true, Dali::Actor::Property::WORLD_ORIENTATION},
+ {"scale", Property::VECTOR3, true, true, true, Dali::Actor::Property::SCALE},
+ {"scaleX", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_X},
+ {"scaleY", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Y},
+ {"scaleZ", Property::FLOAT, true, true, true, Dali::Actor::Property::SCALE_Z},
+ {"worldScale", Property::VECTOR3, false, false, true, Dali::Actor::Property::WORLD_SCALE},
+ {"visible", Property::BOOLEAN, true, true, true, Dali::Actor::Property::VISIBLE},
+ {"color", Property::VECTOR4, true, true, true, Dali::Actor::Property::COLOR},
+ {"colorRed", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_RED},
+ {"colorGreen", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_GREEN},
+ {"colorBlue", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_BLUE},
+ {"colorAlpha", Property::FLOAT, true, true, true, Dali::Actor::Property::COLOR_ALPHA},
+ {"worldColor", Property::VECTOR4, false, false, true, Dali::Actor::Property::WORLD_COLOR},
+ {"worldMatrix", Property::MATRIX, false, false, true, Dali::Actor::Property::WORLD_MATRIX},
+ {"name", Property::STRING, true, false, false, Dali::Actor::Property::NAME},
+ {"sensitive", Property::BOOLEAN, true, false, false, Dali::Actor::Property::SENSITIVE},
+ {"leaveRequired", Property::BOOLEAN, true, false, false, Dali::Actor::Property::LEAVE_REQUIRED},
+ {"inheritOrientation", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_ORIENTATION},
+ {"inheritScale", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_SCALE},
+ {"colorMode", Property::INTEGER, true, false, false, Dali::Actor::Property::COLOR_MODE},
+ {"drawMode", Property::INTEGER, true, false, false, Dali::Actor::Property::DRAW_MODE},
+ {"sizeModeFactor", Property::VECTOR3, true, false, false, Dali::Actor::Property::SIZE_MODE_FACTOR},
+ {"widthResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::WIDTH_RESIZE_POLICY},
+ {"heightResizePolicy", Property::STRING, true, false, false, Dali::Actor::Property::HEIGHT_RESIZE_POLICY},
+ {"sizeScalePolicy", Property::INTEGER, true, false, false, Dali::Actor::Property::SIZE_SCALE_POLICY},
+ {"widthForHeight", Property::BOOLEAN, true, false, false, Dali::Actor::Property::WIDTH_FOR_HEIGHT},
+ {"heightForWidth", Property::BOOLEAN, true, false, false, Dali::Actor::Property::HEIGHT_FOR_WIDTH},
+ {"padding", Property::VECTOR4, true, false, false, Dali::Actor::Property::PADDING},
+ {"minimumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MINIMUM_SIZE},
+ {"maximumSize", Property::VECTOR2, true, false, false, Dali::Actor::Property::MAXIMUM_SIZE},
+ {"inheritPosition", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_POSITION},
+ {"clippingMode", Property::STRING, true, false, false, Dali::Actor::Property::CLIPPING_MODE},
+ {"layoutDirection", Property::STRING, true, false, false, Dali::Actor::Property::LAYOUT_DIRECTION},
+ {"inheritLayoutDirection", Property::BOOLEAN, true, false, false, Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION},
+ {"opacity", Property::FLOAT, true, true, true, Dali::Actor::Property::OPACITY},
+ {"screenPosition", Property::VECTOR2, false, false, false, Dali::Actor::Property::SCREEN_POSITION},
+ {"positionUsesAnchorPoint", Property::BOOLEAN, true, false, false, Dali::Actor::Property::POSITION_USES_ANCHOR_POINT},
+ {"culled", Property::BOOLEAN, false, false, true, Dali::Actor::Property::CULLED},
+ {"id", Property::INTEGER, false, false, false, Dali::Actor::Property::ID},
+ {"hierarchyDepth", Property::INTEGER, false, false, false, Dali::Actor::Property::HIERARCHY_DEPTH},
+ {"isRoot", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_ROOT},
+ {"isLayer", Property::BOOLEAN, false, false, false, Dali::Actor::Property::IS_LAYER},
+ {"connectedToScene", Property::BOOLEAN, false, false, false, Dali::Actor::Property::CONNECTED_TO_SCENE},
+ {"keyboardFocusable", Property::BOOLEAN, true, false, false, Dali::Actor::Property::KEYBOARD_FOCUSABLE},
+ {"siblingOrder", Property::INTEGER, true, false, false, Dali::DevelActor::Property::SIBLING_ORDER},
+ // camera own
+ {"type", Property::STRING, true, false, true, Dali::CameraActor::Property::TYPE},
+ {"projectionMode", Property::STRING, true, false, true, Dali::CameraActor::Property::PROJECTION_MODE},
+ {"fieldOfView", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FIELD_OF_VIEW},
+ {"aspectRatio", Property::FLOAT, true, false, true, Dali::CameraActor::Property::ASPECT_RATIO},
+ {"nearPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::NEAR_PLANE_DISTANCE},
+ {"farPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::FAR_PLANE_DISTANCE},
+ {"leftPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::LEFT_PLANE_DISTANCE},
+ {"rightPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE},
+ {"topPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::TOP_PLANE_DISTANCE},
+ {"bottomPlaneDistance", Property::FLOAT, true, false, true, Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE},
+ {"targetPosition", Property::VECTOR3, true, false, true, Dali::CameraActor::Property::TARGET_POSITION},
+ {"projectionMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::PROJECTION_MATRIX},
+ {"viewMatrix", Property::MATRIX, false, false, true, Dali::CameraActor::Property::VIEW_MATRIX},
+ {"invertYAxis", Property::BOOLEAN, true, false, true, Dali::CameraActor::Property::INVERT_Y_AXIS}};
+
+ for(uint32_t index = 0; index < (sizeof(CAMERA_DEFAULT_PROPERTY) / sizeof(PropertyDetails)); ++index)
+ {
+ TEST_CAMERA_PROPERTY(actor,
+ CAMERA_DEFAULT_PROPERTY[index].name,
+ CAMERA_DEFAULT_PROPERTY[index].type,
+ CAMERA_DEFAULT_PROPERTY[index].writable,
+ CAMERA_DEFAULT_PROPERTY[index].animatable,
+ CAMERA_DEFAULT_PROPERTY[index].constraintInput,
+ CAMERA_DEFAULT_PROPERTY[index].enumIndex,
+ TEST_LOCATION);
}
END_TEST;
}
int UtcDaliCameraActorModelView(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor Test view application" );
+ tet_infoline("Testing Dali::CameraActor Test view application");
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::POSITION, Vector3( 20.0f, 30.0f, 40.0f ));
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(20.0f, 30.0f, 40.0f));
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ application.GetScene().Add(actor);
application.SendNotification();
- application.Render( 0 );
+ application.Render(0);
application.Render();
application.SendNotification();
- Matrix resultMatrix( true );
- resultMatrix.SetTransformComponents( Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) );
+ Matrix resultMatrix(true);
+ resultMatrix.SetTransformComponents(Vector3::ONE, Quaternion::IDENTITY, actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION));
- RenderTask task = application.GetScene().GetRenderTaskList().GetTask( 0 );
+ RenderTask task = application.GetScene().GetRenderTaskList().GetTask(0);
CameraActor cameraActor = task.GetCameraActor();
- Matrix viewMatrix( false );
- cameraActor.GetProperty( CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
- Matrix::Multiply( resultMatrix, resultMatrix, viewMatrix );
+ Matrix viewMatrix(false);
+ cameraActor.GetProperty(CameraActor::Property::VIEW_MATRIX).Get(viewMatrix);
+ Matrix::Multiply(resultMatrix, resultMatrix, viewMatrix);
- DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( "uModelView", resultMatrix ) );
+ DALI_TEST_CHECK(application.GetGlAbstraction().CheckUniformValue("uModelView", resultMatrix));
END_TEST;
}
int UtcDaliCameraActorReadProjectionMatrix(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::CameraActor::ReadProjectionMatrix()" );
+ tet_infoline("Testing Dali::CameraActor::ReadProjectionMatrix()");
- CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
+ CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
application.SendNotification();
- application.Render( 0 );
+ application.Render(0);
application.Render();
application.SendNotification();
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 4u, 4u);
- Actor actor = CreateRenderableActor( image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- application.GetScene().Add( actor );
+ Actor actor = CreateRenderableActor(image, RENDER_SHADOW_VERTEX_SOURCE, RENDER_SHADOW_FRAGMENT_SOURCE);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
Matrix projectionMatrix;
Matrix viewMatrix;
- camera.GetProperty( CameraActor::CameraActor::Property::PROJECTION_MATRIX ).Get( projectionMatrix );
- camera.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( viewMatrix );
+ camera.GetProperty(CameraActor::CameraActor::Property::PROJECTION_MATRIX).Get(projectionMatrix);
+ camera.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(viewMatrix);
- actor.RegisterProperty( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
- actor.RegisterProperty( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY );
+ actor.RegisterProperty(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME, Matrix::IDENTITY);
+ actor.RegisterProperty(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME, Matrix::IDENTITY);
- Property::Index projectionMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME );
- Property::Index viewMatrixPropertyIndex = actor.GetPropertyIndex( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME );
+ Property::Index projectionMatrixPropertyIndex = actor.GetPropertyIndex(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME);
+ Property::Index viewMatrixPropertyIndex = actor.GetPropertyIndex(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME);
- Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>( actor, projectionMatrixPropertyIndex, EqualToConstraint() );
- projectionMatrixConstraint.AddSource( Source( camera, CameraActor::Property::PROJECTION_MATRIX ) );
- Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>( actor, viewMatrixPropertyIndex, EqualToConstraint() );
- viewMatrixConstraint.AddSource( Source( camera, CameraActor::Property::VIEW_MATRIX ) );
+ Constraint projectionMatrixConstraint = Constraint::New<Dali::Matrix>(actor, projectionMatrixPropertyIndex, EqualToConstraint());
+ projectionMatrixConstraint.AddSource(Source(camera, CameraActor::Property::PROJECTION_MATRIX));
+ Constraint viewMatrixConstraint = Constraint::New<Dali::Matrix>(actor, viewMatrixPropertyIndex, EqualToConstraint());
+ viewMatrixConstraint.AddSource(Source(camera, CameraActor::Property::VIEW_MATRIX));
projectionMatrixConstraint.Apply();
viewMatrixConstraint.Apply();
application.Render();
// Test effects of Constraint.
- DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME.c_str(), projectionMatrix) );
+ DALI_TEST_CHECK(application.GetGlAbstraction().CheckUniformValue(SHADER_LIGHT_CAMERA_PROJECTION_MATRIX_PROPERTY_NAME.c_str(), projectionMatrix));
- DALI_TEST_CHECK( application.GetGlAbstraction().CheckUniformValue( SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME.c_str(), viewMatrix ) );
+ DALI_TEST_CHECK(application.GetGlAbstraction().CheckUniformValue(SHADER_LIGHT_CAMERA_VIEW_MATRIX_PROPERTY_NAME.c_str(), viewMatrix));
END_TEST;
}
int UtcDaliCameraActorAnimatedProperties(void)
{
TestApplication application;
- tet_infoline( "Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()" );
+ tet_infoline("Testing Dali::Internal::CameraActor::GetSceneObjectAnimatableProperty()");
- CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- application.GetScene().Add( actor );
+ CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ application.GetScene().Add(actor);
- Constraint constraint = Constraint::New<Dali::Vector3>( actor, Actor::Property::POSITION, EqualToConstraint() );
- constraint.AddSource( Source( camera, Actor::Property::POSITION ) );
+ Constraint constraint = Constraint::New<Dali::Vector3>(actor, Actor::Property::POSITION, EqualToConstraint());
+ constraint.AddSource(Source(camera, Actor::Property::POSITION));
constraint.Apply();
- camera.SetProperty( Actor::Property::POSITION, Vector3( 100.0f, 200.0f, 300.0f ));
+ camera.SetProperty(Actor::Property::POSITION, Vector3(100.0f, 200.0f, 300.0f));
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3( 100.0f, 200.0f, 300.0f ), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3(100.0f, 200.0f, 300.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorPropertyIndices(void)
{
TestApplication application;
- CameraActor camera = application.GetScene().GetRenderTaskList().GetTask( 0u ).GetCameraActor();
+ CameraActor camera = application.GetScene().GetRenderTaskList().GetTask(0u).GetCameraActor();
- Actor basicActor = Actor::New();
+ Actor basicActor = Actor::New();
Property::IndexContainer indices;
- camera.GetPropertyIndices( indices );
- DALI_TEST_CHECK( indices.Size() > basicActor.GetPropertyCount() );
- DALI_TEST_EQUALS( indices.Size(), camera.GetPropertyCount(), TEST_LOCATION );
+ camera.GetPropertyIndices(indices);
+ DALI_TEST_CHECK(indices.Size() > basicActor.GetPropertyCount());
+ DALI_TEST_EQUALS(indices.Size(), camera.GetPropertyCount(), TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorCheckLookAtAndFreeLookViews01(void)
{
- TestApplication application;
- Integration::Scene stage = application.GetScene();
- Vector2 stageSize = stage.GetSize();
+ TestApplication application;
+ Integration::Scene stage = application.GetScene();
+ Vector2 stageSize = stage.GetSize();
- CameraActor freeLookCameraActor = CameraActor::New( stageSize );
- freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- freeLookCameraActor.SetType( Camera::FREE_LOOK );
+ CameraActor freeLookCameraActor = CameraActor::New(stageSize);
+ freeLookCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
- Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
- Actor target = Actor::New();
- target.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- target.SetProperty( Actor::Property::POSITION, targetPosition );
+ Vector3 targetPosition(30.0f, 240.0f, -256.0f);
+ Actor target = Actor::New();
+ target.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ target.SetProperty(Actor::Property::POSITION, targetPosition);
- Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
- cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
- cameraOrientationConstraint.AddSource( Source( freeLookCameraActor, Actor::Property::WORLD_POSITION ) );
- cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
+ Constraint cameraOrientationConstraint = Constraint::New<Quaternion>(freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt);
+ cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_POSITION));
+ cameraOrientationConstraint.AddSource(Source(freeLookCameraActor, Actor::Property::WORLD_POSITION));
+ cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_ORIENTATION));
cameraOrientationConstraint.Apply();
- CameraActor lookAtCameraActor = CameraActor::New( stageSize );
- lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
- lookAtCameraActor.SetTargetPosition( targetPosition );
- lookAtCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ CameraActor lookAtCameraActor = CameraActor::New(stageSize);
+ lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
+ lookAtCameraActor.SetTargetPosition(targetPosition);
+ lookAtCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- stage.Add( target );
- stage.Add( freeLookCameraActor );
- stage.Add( lookAtCameraActor );
+ stage.Add(target);
+ stage.Add(freeLookCameraActor);
+ stage.Add(lookAtCameraActor);
// Create an arbitrary vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
- Vector3 position( x, y, z );
+ Vector3 position(x, y, z);
position.Normalize();
position *= 200.0f;
- freeLookCameraActor.SetProperty( Actor::Property::POSITION, position );
- lookAtCameraActor.SetProperty( Actor::Property::POSITION, position );
+ freeLookCameraActor.SetProperty(Actor::Property::POSITION, position);
+ lookAtCameraActor.SetProperty(Actor::Property::POSITION, position);
application.SendNotification();
application.Render();
application.Render();
Matrix freeLookViewMatrix;
Matrix lookAtViewMatrix;
- freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
- lookAtCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( lookAtViewMatrix );
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(freeLookViewMatrix);
+ lookAtCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(lookAtViewMatrix);
- DALI_TEST_EQUALS( freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION );
+ DALI_TEST_EQUALS(freeLookViewMatrix, lookAtViewMatrix, 0.01, TEST_LOCATION);
}
}
}
int UtcDaliCameraActorCheckLookAtAndFreeLookViews02(void)
{
- TestApplication application;
- Integration::Scene stage = application.GetScene();
- Vector2 stageSize = stage.GetSize();
+ TestApplication application;
+ Integration::Scene stage = application.GetScene();
+ Vector2 stageSize = stage.GetSize();
- CameraActor freeLookCameraActor = CameraActor::New( stageSize );
- freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- freeLookCameraActor.SetType( Camera::FREE_LOOK );
+ CameraActor freeLookCameraActor = CameraActor::New(stageSize);
+ freeLookCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
- Vector3 targetPosition( 30.0f, 240.0f, -256.0f );
- Actor target = Actor::New();
- target.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- target.SetProperty( Actor::Property::POSITION, targetPosition );
+ Vector3 targetPosition(30.0f, 240.0f, -256.0f);
+ Actor target = Actor::New();
+ target.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ target.SetProperty(Actor::Property::POSITION, targetPosition);
- Constraint cameraOrientationConstraint = Constraint::New<Quaternion> ( freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt );
- cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_POSITION ) );
- cameraOrientationConstraint.AddSource( Source( freeLookCameraActor, Actor::Property::WORLD_POSITION ) );
- cameraOrientationConstraint.AddSource( Source( target, Actor::Property::WORLD_ORIENTATION ) );
+ Constraint cameraOrientationConstraint = Constraint::New<Quaternion>(freeLookCameraActor, Actor::Property::ORIENTATION, &LookAt);
+ cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_POSITION));
+ cameraOrientationConstraint.AddSource(Source(freeLookCameraActor, Actor::Property::WORLD_POSITION));
+ cameraOrientationConstraint.AddSource(Source(target, Actor::Property::WORLD_ORIENTATION));
cameraOrientationConstraint.Apply();
- CameraActor lookAtCameraActor = CameraActor::New( stageSize );
- lookAtCameraActor.SetType( Camera::LOOK_AT_TARGET );
- lookAtCameraActor.SetTargetPosition( targetPosition );
- lookAtCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ CameraActor lookAtCameraActor = CameraActor::New(stageSize);
+ lookAtCameraActor.SetType(Camera::LOOK_AT_TARGET);
+ lookAtCameraActor.SetTargetPosition(targetPosition);
+ lookAtCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- stage.Add( target );
- stage.Add( freeLookCameraActor );
- stage.Add( lookAtCameraActor );
- stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
+ stage.Add(target);
+ stage.Add(freeLookCameraActor);
+ stage.Add(lookAtCameraActor);
+ stage.GetRenderTaskList().GetTask(0).SetCameraActor(freeLookCameraActor);
// Create an arbitrary vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
- Vector3 position( x, y, z );
+ Vector3 position(x, y, z);
position.Normalize();
position *= 200.0f;
- freeLookCameraActor.SetProperty( Actor::Property::POSITION, position );
- lookAtCameraActor.SetProperty( Actor::Property::POSITION, position );
+ freeLookCameraActor.SetProperty(Actor::Property::POSITION, position);
+ lookAtCameraActor.SetProperty(Actor::Property::POSITION, position);
application.SendNotification();
application.Render();
application.SendNotification();
application.Render();
Matrix freeLookViewMatrix;
- freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(freeLookViewMatrix);
- Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
+ Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
- Matrix freeLookTest( false );
- Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
- DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
+ Matrix freeLookTest(false);
+ Matrix::Multiply(freeLookTest, freeLookViewMatrix, freeLookWorld);
+ DALI_TEST_EQUALS(freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION);
}
}
}
int UtcDaliCameraActorCheckLookAtAndFreeLookViews03(void)
{
- TestApplication application;
- Integration::Scene stage = application.GetScene();
- Vector2 stageSize = stage.GetSize();
+ TestApplication application;
+ Integration::Scene stage = application.GetScene();
+ Vector2 stageSize = stage.GetSize();
- Vector3 targetPosition( Vector3::ZERO );
- Vector3 cameraOffset( 0.0f, 0.0f, 100.0f );
+ Vector3 targetPosition(Vector3::ZERO);
+ Vector3 cameraOffset(0.0f, 0.0f, 100.0f);
- CameraActor freeLookCameraActor = CameraActor::New( stageSize );
- freeLookCameraActor.SetType( Camera::FREE_LOOK );
- freeLookCameraActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ CameraActor freeLookCameraActor = CameraActor::New(stageSize);
+ freeLookCameraActor.SetType(Camera::FREE_LOOK);
+ freeLookCameraActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
- Quaternion cameraOrientation( Radian( Degree( 180.0f ) ), Vector3::YAXIS );
- freeLookCameraActor.SetProperty( Actor::Property::POSITION, cameraOffset );
- freeLookCameraActor.SetProperty( Actor::Property::ORIENTATION, cameraOrientation );
+ Quaternion cameraOrientation(Radian(Degree(180.0f)), Vector3::YAXIS);
+ freeLookCameraActor.SetProperty(Actor::Property::POSITION, cameraOffset);
+ freeLookCameraActor.SetProperty(Actor::Property::ORIENTATION, cameraOrientation);
Actor cameraAnchor = Actor::New();
- cameraAnchor.Add( freeLookCameraActor );
- stage.Add( cameraAnchor );
- stage.GetRenderTaskList().GetTask(0).SetCameraActor( freeLookCameraActor );
+ cameraAnchor.Add(freeLookCameraActor);
+ stage.Add(cameraAnchor);
+ stage.GetRenderTaskList().GetTask(0).SetCameraActor(freeLookCameraActor);
- for( float angle = 1.0f; angle <= 180.0f; angle += 1.0f )
+ for(float angle = 1.0f; angle <= 180.0f; angle += 1.0f)
{
- Quaternion rotation( Radian( Degree( angle ) ), Vector3::YAXIS );
+ Quaternion rotation(Radian(Degree(angle)), Vector3::YAXIS);
- freeLookCameraActor.SetProperty( Actor::Property::POSITION, rotation.Rotate( cameraOffset ) );
- cameraAnchor.SetProperty( Actor::Property::ORIENTATION, rotation );
+ freeLookCameraActor.SetProperty(Actor::Property::POSITION, rotation.Rotate(cameraOffset));
+ cameraAnchor.SetProperty(Actor::Property::ORIENTATION, rotation);
application.SendNotification();
application.Render();
application.Render();
Matrix freeLookViewMatrix;
- freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( freeLookViewMatrix );
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(freeLookViewMatrix);
- Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
+ Matrix freeLookWorld = freeLookCameraActor.GetCurrentProperty<Matrix>(Actor::Property::WORLD_MATRIX);
- Matrix freeLookTest( false );
- Matrix::Multiply( freeLookTest, freeLookViewMatrix, freeLookWorld );
- DALI_TEST_EQUALS( freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION );
+ Matrix freeLookTest(false);
+ Matrix::Multiply(freeLookTest, freeLookViewMatrix, freeLookWorld);
+ DALI_TEST_EQUALS(freeLookTest, Matrix::IDENTITY, 0.01f, TEST_LOCATION);
}
END_TEST;
}
Integration::Scene stage = application.GetScene();
- Vector3 targetPosition( Vector3::ZERO );
- Vector3 cameraOffset( 0.0f, 100.0f, 100.0f );
+ Vector3 targetPosition(Vector3::ZERO);
+ Vector3 cameraOffset(0.0f, 100.0f, 100.0f);
CameraActor freeLookCameraActor = stage.GetRenderTaskList().GetTask(0).GetCameraActor();
freeLookCameraActor.SetType(Camera::LOOK_AT_TARGET);
- freeLookCameraActor.SetTargetPosition( targetPosition );
- freeLookCameraActor.SetProperty( Actor::Property::POSITION, cameraOffset );
+ freeLookCameraActor.SetTargetPosition(targetPosition);
+ freeLookCameraActor.SetProperty(Actor::Property::POSITION, cameraOffset);
- stage.GetRootLayer().SetProperty( Actor::Property::POSITION, Vector2( 1, 0 ));
+ stage.GetRootLayer().SetProperty(Actor::Property::POSITION, Vector2(1, 0));
application.SendNotification();
application.Render();
application.Render();
Matrix matrixBefore, matrixAfter;
- freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( matrixBefore );
- freeLookCameraActor.SetProperty( Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4( 0.0f, 1.0f, 0.0f, 0.0f));
- stage.GetRootLayer().SetProperty( Actor::Property::POSITION, Vector2( 0, 0 ));
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(matrixBefore);
+ freeLookCameraActor.SetProperty(Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+ stage.GetRootLayer().SetProperty(Actor::Property::POSITION, Vector2(0, 0));
application.SendNotification();
application.Render();
application.SendNotification();
application.Render();
- freeLookCameraActor.GetProperty( CameraActor::CameraActor::Property::VIEW_MATRIX ).Get( matrixAfter );
+ freeLookCameraActor.GetProperty(CameraActor::CameraActor::Property::VIEW_MATRIX).Get(matrixAfter);
- Vector3 position, scale;
+ Vector3 position, scale;
Quaternion rotation;
- matrixAfter.GetTransformComponents( position, rotation, scale );
+ matrixAfter.GetTransformComponents(position, rotation, scale);
- Quaternion reflected( 0, 0, 1, 0 );
+ Quaternion reflected(0, 0, 1, 0);
- DALI_TEST_EQUALS( reflected, rotation, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(reflected, rotation, 0.01f, TEST_LOCATION);
// Test Free Look camera
freeLookCameraActor.SetType(Camera::FREE_LOOK);
// Make sure the recalculation will take place
- freeLookCameraActor.SetProperty( Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4( 0.0f, 1.0f, 0.0f, 0.0f));
+ freeLookCameraActor.SetProperty(Dali::DevelCameraActor::Property::REFLECTION_PLANE, Vector4(0.0f, 1.0f, 0.0f, 0.0f));
application.SendNotification();
application.Render();
application.Render();
// Nothing should change despite of different camera type
- matrixAfter.GetTransformComponents( position, rotation, scale );
- DALI_TEST_EQUALS( reflected, rotation, 0.01f, TEST_LOCATION );
+ matrixAfter.GetTransformComponents(position, rotation, scale);
+ DALI_TEST_EQUALS(reflected, rotation, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliCameraActorGetAspectRatioNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetFieldOfViewNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetInvertYAxisNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetAspectRatioNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetFieldOfViewNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetInvertYAxisNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetProjectionModeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetTargetPositionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetFarClippingPlaneNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetFarClippingPlaneNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetNearClippingPlaneNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetNearClippingPlaneNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetPerspectiveProjectionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetOrthographicProjectionNegative01(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
float arg4(0.0f);
float arg5(0.0f);
float arg6(0.0f);
- instance.SetOrthographicProjection(arg1,arg2,arg3,arg4,arg5,arg6);
+ instance.SetOrthographicProjection(arg1, arg2, arg3, arg4, arg5, arg6);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliCameraActorSetOrthographicProjectionNegative02(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorSetTypeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetProjectionModeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetTargetPositionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
int UtcDaliCameraActorGetTypeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::CameraActor instance;
try
{
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
#define ENABLE_VECTOR_ASSERTS
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/common/circular-queue.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/common/circular-queue.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-
int UtcDaliCircularQueueNew(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
- DALI_TEST_EQUALS( cQ.Count(), 0, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.Count(), 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliCircularQueuePushBack01(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
- cQ.PushBack( 1 );
- DALI_TEST_EQUALS( cQ.Count(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ cQ.PushBack(1);
+ DALI_TEST_EQUALS(cQ.Count(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
- DALI_TEST_EQUALS( cQ[0], 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ[0], 1, TEST_LOCATION);
- cQ.PushBack( 2 );
- DALI_TEST_EQUALS( cQ.Count(), 2, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ cQ.PushBack(2);
+ DALI_TEST_EQUALS(cQ.Count(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
- DALI_TEST_EQUALS( cQ[0], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ[1], 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ[0], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ[1], 2, TEST_LOCATION);
END_TEST;
}
int UtcDaliCircularQueuePushBack02(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<20; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Count(), i+1, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), i<19?false:true, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Count(), i + 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), i < 19 ? false : true, TEST_LOCATION);
}
END_TEST;
int UtcDaliCircularQueuePushBack03(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<19; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 19; ++i)
{
- cQ.PushBack( i );
+ cQ.PushBack(i);
}
cQ.PushBack(19);
- DALI_TEST_EQUALS( cQ.IsFull(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.IsFull(), true, TEST_LOCATION);
- for( int i=0; i<10; ++i )
+ for(int i = 0; i < 10; ++i)
{
- tet_infoline( "Test that the end marker wraps around");
+ tet_infoline("Test that the end marker wraps around");
(void)cQ.PopFront();
- cQ.PushBack(20+i);
- DALI_TEST_EQUALS( cQ.IsFull(), true, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ[0], 1+i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ[19], 20+i, TEST_LOCATION );
+ cQ.PushBack(20 + i);
+ DALI_TEST_EQUALS(cQ.IsFull(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ[0], 1 + i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ[19], 20 + i, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliCircularQueuePushBack04(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<10; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 10; ++i)
{
- cQ.PushBack( i );
+ cQ.PushBack(i);
int v = cQ.PopFront();
- DALI_TEST_EQUALS( v, i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.Count(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(v, i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.Count(), 0, TEST_LOCATION);
}
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
// Queue is empty
cQ.PushBack(10);
- DALI_TEST_EQUALS( cQ[0], 10, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.Count(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ[0], 10, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.Count(), 1, TEST_LOCATION);
(void)cQ.PopFront();
- DALI_TEST_EQUALS( cQ.Count(), 0, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.Count(), 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
// Queue is empty, markers should be in middle
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
+ cQ.PushBack(i);
int v = cQ.PopFront();
- DALI_TEST_EQUALS( v, i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.Count(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(v, i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.Count(), 0, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliCircularQueuePushBackN(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<20; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Count(), i+1, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), i<19?false:true, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Count(), i + 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), i < 19 ? false : true, TEST_LOCATION);
}
try
{
- cQ.PushBack( 20 );
- DALI_TEST_EQUALS( 0, 1, TEST_LOCATION );// Failure
+ cQ.PushBack(20);
+ DALI_TEST_EQUALS(0, 1, TEST_LOCATION); // Failure
}
- catch( DaliException e )
+ catch(DaliException e)
{
- DALI_TEST_EQUALS( 1, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(1, 1, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliCircularQueueOperatorIndex01(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<20; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Count(), 1+i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), i<19?false:true, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Count(), 1 + i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), i < 19 ? false : true, TEST_LOCATION);
}
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- DALI_TEST_EQUALS( cQ[i], i, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ[i], i, TEST_LOCATION);
}
END_TEST;
int UtcDaliCircularQueueOperatorIndexN01(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
try
{
int v = cQ[0];
DALI_TEST_EQUALS(v, 1, TEST_LOCATION);
}
- catch( DaliException e )
+ catch(DaliException e)
{
DALI_TEST_CHECK(true);
}
END_TEST;
}
-
int UtcDaliCircularQueuePopFront01(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<20; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Count(), 1+i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), i<19?false:true, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Count(), 1 + i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), i < 19 ? false : true, TEST_LOCATION);
}
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
int v = cQ.PopFront();
- DALI_TEST_EQUALS( cQ.Count(), 19-i, TEST_LOCATION );
- DALI_TEST_EQUALS( v, i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), i<19?false:true, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.Count(), 19 - i, TEST_LOCATION);
+ DALI_TEST_EQUALS(v, i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), i < 19 ? false : true, TEST_LOCATION);
}
END_TEST;
}
int UtcDaliCircularQueuePopFront02(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- for( int i=0; i<10; ++i)
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ for(int i = 0; i < 10; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ[i], i, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.Count(), i+1, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ[i], i, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.Count(), i + 1, TEST_LOCATION);
}
- for( int i=0; i<10; ++i)
+ for(int i = 0; i < 10; ++i)
{
- DALI_TEST_EQUALS( cQ.PopFront(), i, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.PopFront(), i, TEST_LOCATION);
}
- DALI_TEST_EQUALS( cQ.Count(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.Count(), 0, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliCircularQueuePopFrontN01(void)
{
tet_infoline("Try popping from an empty queue");
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
try
{
(void)cQ.PopFront();
- DALI_TEST_CHECK( false );
+ DALI_TEST_CHECK(false);
}
- catch( DaliException e )
+ catch(DaliException e)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
}
-
int UtcDaliCircularQueuePopFrontN02(void)
{
tet_infoline("Try popping from an empty queue");
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
- for( int i=0; i<10; ++i)
+ for(int i = 0; i < 10; ++i)
{
- cQ.PushBack( i );
+ cQ.PushBack(i);
(void)cQ.PopFront();
}
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
try
{
(void)cQ.PopFront();
- DALI_TEST_CHECK( false );
+ DALI_TEST_CHECK(false);
}
- catch( DaliException e )
+ catch(DaliException e)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
int UtcDaliCircularQueueCount(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- DALI_TEST_EQUALS( cQ.Count(), 0, TEST_LOCATION );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ DALI_TEST_EQUALS(cQ.Count(), 0, TEST_LOCATION);
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Count(), 1+i, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Count(), 1 + i, TEST_LOCATION);
}
END_TEST;
int UtcDaliCircularQueueIsEmpty(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
}
// Pop off 19 elements
- for( int i=0; i<19; ++i)
+ for(int i = 0; i < 19; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
}
// pop off last element
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
- tet_infoline( "Add half into queue, then remove");
+ tet_infoline("Add half into queue, then remove");
- for( int i=0; i<10; ++i)
+ for(int i = 0; i < 10; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
}
- for( int i=0; i<9; ++i)
+ for(int i = 0; i < 9; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
}
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
tet_infoline("Markers should now be in the middle of the data structure. Try adding 20 again");
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
}
- for( int i=0; i<19; ++i)
+ for(int i = 0; i < 19; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
}
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliCircularQueueIsFull(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.IsFull(), i<19?false:true, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.IsFull(), i < 19 ? false : true, TEST_LOCATION);
}
- DALI_TEST_EQUALS( cQ.IsFull(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.IsFull(), true, TEST_LOCATION);
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
}
- tet_infoline( "Add half into queue, then remove");
+ tet_infoline("Add half into queue, then remove");
- for( int i=0; i<10; ++i)
+ for(int i = 0; i < 10; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
}
- for( int i=0; i<10; ++i)
+ for(int i = 0; i < 10; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
}
tet_infoline("Markers should now be in the middle of the data structure. Try adding 20 again");
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.IsFull(), i<19?false:true, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.IsFull(), i < 19 ? false : true, TEST_LOCATION);
}
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliCircularQueueFront(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Front(), 0, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Front(), 0, TEST_LOCATION);
}
- for( int i=0; i<19; ++i)
+ for(int i = 0; i < 19; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.Front(), i+1, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.Front(), i + 1, TEST_LOCATION);
}
END_TEST;
}
int UtcDaliCircularQueueBack(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 20 );
+ CircularQueue<int> cQ = CircularQueue<int>(20);
- for( int i=0; i<20; ++i)
+ for(int i = 0; i < 20; ++i)
{
- cQ.PushBack( i );
- DALI_TEST_EQUALS( cQ.Back(), i, TEST_LOCATION );
+ cQ.PushBack(i);
+ DALI_TEST_EQUALS(cQ.Back(), i, TEST_LOCATION);
}
- for( int i=0; i<19; ++i)
+ for(int i = 0; i < 19; ++i)
{
- (void) cQ.PopFront();
- DALI_TEST_EQUALS( cQ.Back(), 19, TEST_LOCATION );
+ (void)cQ.PopFront();
+ DALI_TEST_EQUALS(cQ.Back(), 19, TEST_LOCATION);
}
END_TEST;
}
int UtcDaliCircularQueueSize1(void)
{
- CircularQueue<int> cQ = CircularQueue<int>( 1 );
+ CircularQueue<int> cQ = CircularQueue<int>(1);
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
- cQ.PushBack( 5 );
- DALI_TEST_EQUALS( cQ.IsEmpty(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), true, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.Front(), 5, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.Back(), 5, TEST_LOCATION );
+ cQ.PushBack(5);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.Front(), 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.Back(), 5, TEST_LOCATION);
- DALI_TEST_EQUALS( cQ.PopFront(), 5, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsEmpty(), true, TEST_LOCATION );
- DALI_TEST_EQUALS( cQ.IsFull(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(cQ.PopFront(), 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsEmpty(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(cQ.IsFull(), false, TEST_LOCATION);
END_TEST;
}
+// pushback
+// . => [O]
+// se se
- // pushback
- // . => [O]
- // se se
-
- // [O] => [O] [O]
- // se s e
+// [O] => [O] [O]
+// se s e
- // [O] [O] [O] [O] [O] [ ] => [O] [O] [O] [O] [O] [O]
- // s e s e
+// [O] [O] [O] [O] [O] [ ] => [O] [O] [O] [O] [O] [O]
+// s e s e
- // [ ] [O] [O] [O] [O] [O] => [O] [O] [O] [O] [O] [O]
- // s e e s
+// [ ] [O] [O] [O] [O] [O] => [O] [O] [O] [O] [O] [O]
+// s e e s
- // [ ] [ ] [O] [ ] [ ] [ ] => [ ] [ ] [O] [O] [ ] [ ]
- // se s e
+// [ ] [ ] [O] [ ] [ ] [ ] => [ ] [ ] [O] [O] [ ] [ ]
+// se s e
- // [ ] [ ] [ ] [ ] [ ] [O] => [O] [ ] [ ] [ ] [ ] [O]
- // se e s
+// [ ] [ ] [ ] [ ] [ ] [O] => [O] [ ] [ ] [ ] [ ] [O]
+// se e s
- // [ ] [ ] [ ] [ ] [ ] [ ] => [ ] [ ] [O] [ ] [ ] [ ]
- // se se
+// [ ] [ ] [ ] [ ] [ ] [ ] => [ ] [ ] [O] [ ] [ ] [ ]
+// se se
- // [ ] [ ] [ ] [ ] [ ] [ ] => [ ] [ ] [ ] [ ] [ ] [0]
- // se se
- // popfront
- // [O] [O] [O] [O] [O] [O] => [ ] [O] [O] [O] [O] [O]
- // s e s e
+// [ ] [ ] [ ] [ ] [ ] [ ] => [ ] [ ] [ ] [ ] [ ] [0]
+// se se
+// popfront
+// [O] [O] [O] [O] [O] [O] => [ ] [O] [O] [O] [O] [O]
+// s e s e
- // [O] [O] [O] [O] [O] [O] => [O] [O] [O] [O] [ ] [O]
- // e s e s
+// [O] [O] [O] [O] [O] [O] => [O] [O] [O] [O] [ ] [O]
+// e s e s
- // [O] [O] [O] [O] [O] [O] => [O] [O] [O] [O] [O] [ ]
- // e s s e
+// [O] [O] [O] [O] [O] [O] => [O] [O] [O] [O] [O] [ ]
+// e s s e
- // [ ] [ ] [O] [O] [ ] [ ] => [ ] [ ] [ ] [O] [ ] [ ]
- // s e se
+// [ ] [ ] [O] [O] [ ] [ ] => [ ] [ ] [ ] [O] [ ] [ ]
+// s e se
- // [ ] [ ] [ ] [O] [ ] [ ] => [ ] [ ] [ ] [ ] [ ] [ ]
- // se se
+// [ ] [ ] [ ] [O] [ ] [ ] => [ ] [ ] [ ] [ ] [ ] [ ]
+// se se
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <unistd.h>
-#include <type_traits>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/threading/conditional-wait.h>
#include <dali/devel-api/threading/thread.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <iostream>
+#include <type_traits>
using Dali::ConditionalWait;
using Dali::Thread;
namespace // for local variables to avoid name clashes
{
-volatile int gGlobalValue = 0;
+volatile int gGlobalValue = 0;
volatile bool gWorkerThreadWait = true;
-enum ThreadState { INIT, RUN, TERMINATE } volatile gWorkerThreadState = INIT;
+enum ThreadState
+{
+ INIT,
+ RUN,
+ TERMINATE
+} volatile gWorkerThreadState = INIT;
ConditionalWait* volatile gConditionalWait; // volatile pointer to a ConditionalWait object
class WorkerThreadNotify : public Thread
virtual void Run()
{
gGlobalValue = -1;
- while( gWorkerThreadWait ) // wait till we can exit
+ while(gWorkerThreadWait) // wait till we can exit
{
gWorkerThreadState = RUN;
- usleep( 1 ); // 1 microseconds
+ usleep(1); // 1 microseconds
}
- usleep( 200 ); // give other thread time to get to Wait
+ usleep(200); // give other thread time to get to Wait
gGlobalValue = 1;
gConditionalWait->Notify();
gWorkerThreadState = TERMINATE;
{
virtual void Run()
{
- while( gNotifyCount > 0 )
+ while(gNotifyCount > 0)
{
gConditionalWait->Notify();
- usleep( 10 ); // 10 microseconds between each notify
+ usleep(10); // 10 microseconds between each notify
}
}
};
}
};
-}
+} // namespace
int UtcConditionalWait1P(void)
{
WorkerThreadNotify thread1;
// initialize values
- gConditionalWait = new ConditionalWait();
+ gConditionalWait = new ConditionalWait();
gWorkerThreadWait = true;
- DALI_TEST_EQUALS( INIT, gWorkerThreadState, TEST_LOCATION );
- DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(INIT, gWorkerThreadState, TEST_LOCATION);
+ DALI_TEST_EQUALS(0, gGlobalValue, TEST_LOCATION);
thread1.Start();
// wait till the thread is in run state
- while( RUN != gWorkerThreadState )
+ while(RUN != gWorkerThreadState)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
// let worker continue and finish
gWorkerThreadWait = false;
gConditionalWait->Wait();
- DALI_TEST_EQUALS( 1, gGlobalValue, TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, gGlobalValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
// wait till the thread is terminated state
- while( TERMINATE != gWorkerThreadState )
+ while(TERMINATE != gWorkerThreadState)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
thread1.Join();
tet_infoline("Testing ConditionalWait - scenario: notify without wait");
ConditionalWait wait;
- DALI_TEST_EQUALS( 0u, wait.GetWaitCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, wait.GetWaitCount(), TEST_LOCATION);
wait.Notify();
- DALI_TEST_EQUALS( 0u, wait.GetWaitCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, wait.GetWaitCount(), TEST_LOCATION);
END_TEST;
}
-
int UtcConditionalWait3P(void)
{
tet_infoline("Testing ConditionalWait - scenario: wait - notify N times 2 threads");
// initialize values
gConditionalWait = new ConditionalWait();
- gNotifyCount = 100;
+ gNotifyCount = 100;
WorkerThreadNotifyN thread1;
thread1.Start();
- while( gNotifyCount > 0 )
+ while(gNotifyCount > 0)
{
gConditionalWait->Wait();
--gNotifyCount;
- DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
- usleep( 10 ); // 10 microseconds between each notify
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
+ usleep(10); // 10 microseconds between each notify
}
- DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
thread1.Join();
// initialize values
gConditionalWait = new ConditionalWait();
- gNotifyCount = 100;
+ gNotifyCount = 100;
WorkerThreadNotifyN thread1;
thread1.Start();
WorkerThreadNotifyN thread3;
thread3.Start();
- while( gNotifyCount > 0 )
+ while(gNotifyCount > 0)
{
gConditionalWait->Wait();
--gNotifyCount;
- DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
- usleep( 10 ); // 10 microseconds between each notify
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
+ usleep(10); // 10 microseconds between each notify
}
thread1.Join();
WorkerThreadWaitN thread4;
thread4.Start();
// wait till all child threads are waiting
- while( gConditionalWait->GetWaitCount() < 4 )
- { }
+ while(gConditionalWait->GetWaitCount() < 4)
+ {
+ }
// notify once, it will resume all threads
gConditionalWait->Notify();
thread3.Join();
thread4.Join();
- DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
delete gConditionalWait;
END_TEST;
WorkerThreadWaitN thread4;
thread4.Start();
// wait till all child threads are waiting
- while( gConditionalWait->GetWaitCount() < 4 )
- { }
+ while(gConditionalWait->GetWaitCount() < 4)
+ {
+ }
// notify once but with a scoped lock, it will resume all threads
{
- ConditionalWait::ScopedLock lock( *gConditionalWait );
- gConditionalWait->Notify( lock );
+ ConditionalWait::ScopedLock lock(*gConditionalWait);
+ gConditionalWait->Notify(lock);
}
thread1.Join();
thread3.Join();
thread4.Join();
- DALI_TEST_EQUALS( 0u, gConditionalWait->GetWaitCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, gConditionalWait->GetWaitCount(), TEST_LOCATION);
delete gConditionalWait;
END_TEST;
{
// we want to make sure that ConditionalWait is not copyable (its copy constructor is not defined)
// this test will stop compiling if ConditionalWait has compiler generated copy constructor
- static_assert( !__has_trivial_copy( ConditionalWait ), "ConditionalWait should NOT be copyable" );
+ static_assert(!__has_trivial_copy(ConditionalWait), "ConditionalWait should NOT be copyable");
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
-
-
*/
// EXTERNAL INCLUDES
-#include <iostream>
#include <stdlib.h>
+#include <iostream>
+
// INTERNAL INCLUDES
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
#include <signal-helper.h>
-
using namespace Dali;
void utc_dali_conenction_tracker_startup(void)
test_return_value = TET_PASS;
}
-namespace {
-
-
-} // anon namespace
-
+namespace
+{
+} // namespace
/*******************************************
*
ConnectionTracker tracker;
- DALI_TEST_CHECK( tracker.GetConnectionCount() == 0 );
+ DALI_TEST_CHECK(tracker.GetConnectionCount() == 0);
END_TEST;
}
TestButton* button = new TestButton(1);
{
TestApp testApp;
- button->DownSignal().Connect(&testApp,&TestApp::OnButtonPress);
- DALI_TEST_CHECK( testApp.GetConnectionCount() == 1 );
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( )== 1 );
+ button->DownSignal().Connect(&testApp, &TestApp::OnButtonPress);
+ DALI_TEST_CHECK(testApp.GetConnectionCount() == 1);
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 1);
}
// testApp out of scope it should have been disconnected
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 0 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 0);
delete button;
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- TestApp testApp;
- button->DownSignal().Connect(&testApp,&TestApp::OnButtonPress);
+ TestApp testApp;
+ button->DownSignal().Connect(&testApp, &TestApp::OnButtonPress);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 1 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 1);
testApp.DisconnectAll();
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 0 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 0);
delete button;
int UtcConnectionTrackerDisconnectAllN(void)
{
TestApplication application; // Create core for debug logging
- TestApp testApp;
- TestButton* button = new TestButton(1);
+ TestApp testApp;
+ TestButton* button = new TestButton(1);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 0 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 0);
testApp.DisconnectAll();
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 0 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 0);
delete button;
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- TestApp testApp;
- button->DownSignal().Connect(&testApp,&TestApp::OnButtonPress);
+ TestApp testApp;
+ button->DownSignal().Connect(&testApp, &TestApp::OnButtonPress);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 1 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 1);
delete button;
END_TEST;
-
}
int UtcConnectionTrackerSignalConnectedN(void)
{
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- TestApp* testApp( NULL );
+ TestApp* testApp(NULL);
try
{
// connect to a null connection tracker
- button->DownSignal().Connect( testApp, &TestApp::OnButtonPress);
+ button->DownSignal().Connect(testApp, &TestApp::OnButtonPress);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
// Tests that a negative test of an assertion succeeds
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_PASS);
}
END_TEST;
}
-
int UtcConnectionTrackerSignalDisconnectP(void)
{
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- TestApp testApp;
- button->DownSignal().Connect(&testApp,&TestApp::OnButtonPress);
+ TestApp testApp;
+ button->DownSignal().Connect(&testApp, &TestApp::OnButtonPress);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 1 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 1);
- button->DownSignal().Disconnect(&testApp,&TestApp::OnButtonPress);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 0 );
+ button->DownSignal().Disconnect(&testApp, &TestApp::OnButtonPress);
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 0);
delete button;
END_TEST;
}
-
int UtcConnectionTrackerSignalDisconnectN(void)
{
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- TestApp testApp;
- button->DownSignal().Connect(&testApp,&TestApp::OnButtonPress);
+ TestApp testApp;
+ button->DownSignal().Connect(&testApp, &TestApp::OnButtonPress);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 1 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 1);
try
{
- application.SignalDisconnected( NULL, NULL );
- tet_result( TET_FAIL );
+ application.SignalDisconnected(NULL, NULL);
+ tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
delete button;
END_TEST;
}
-
int UtcConnectionTrackerGetConnectionCountP(void)
{
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- TestApp testApp;
- button->DownSignal().Connect(&testApp,&TestApp::OnButtonPress);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 1 );
+ TestApp testApp;
+ button->DownSignal().Connect(&testApp, &TestApp::OnButtonPress);
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 1);
delete button;
TestApplication application; // Create core for debug logging
TestButton* button = new TestButton(1);
- DALI_TEST_CHECK( button->DownSignal().GetConnectionCount( ) == 0 );
+ DALI_TEST_CHECK(button->DownSignal().GetConnectionCount() == 0);
delete button;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/animation/path-constrainer.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/animation/path-constrainer.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
using namespace Dali::Internal;
namespace
{
-
-static void SetupPath( Dali::Path& path)
+static void SetupPath(Dali::Path& path)
{
- path.AddPoint(Vector3( 30.0, 80.0, 0.0));
- path.AddPoint(Vector3( 70.0, 120.0, 0.0));
+ path.AddPoint(Vector3(30.0, 80.0, 0.0));
+ path.AddPoint(Vector3(70.0, 120.0, 0.0));
path.AddPoint(Vector3(100.0, 100.0, 0.0));
//Control points for first segment
- path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
- path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+ path.AddControlPoint(Vector3(39.0, 90.0, 0.0));
+ path.AddControlPoint(Vector3(56.0, 119.0, 0.0));
//Control points for second segment
- path.AddControlPoint(Vector3( 78.0, 120.0, 0.0) );
- path.AddControlPoint(Vector3( 93.0, 104.0, 0.0) );
+ path.AddControlPoint(Vector3(78.0, 120.0, 0.0));
+ path.AddControlPoint(Vector3(93.0, 104.0, 0.0));
}
-static void SetupPathConstrainer( Dali::PathConstrainer& PathConstrainer)
+static void SetupPathConstrainer(Dali::PathConstrainer& PathConstrainer)
{
- PathConstrainer.SetProperty( Dali::PathConstrainer::Property::FORWARD, Vector3(1.0f,0.0f,0.0f) );
+ PathConstrainer.SetProperty(Dali::PathConstrainer::Property::FORWARD, Vector3(1.0f, 0.0f, 0.0f));
Dali::Property::Array points;
points.Resize(3);
- points[0] = Vector3( 30.0, 80.0, 0.0);
- points[1] = Vector3( 70.0, 120.0, 0.0);
+ points[0] = Vector3(30.0, 80.0, 0.0);
+ points[1] = Vector3(70.0, 120.0, 0.0);
points[2] = Vector3(100.0, 100.0, 0.0);
- PathConstrainer.SetProperty( Dali::PathConstrainer::Property::POINTS, points );
+ PathConstrainer.SetProperty(Dali::PathConstrainer::Property::POINTS, points);
points.Resize(4);
- points[0] = Vector3( 39.0, 90.0, 0.0);
- points[1] = Vector3( 56.0, 119.0, 0.0);
- points[2] = Vector3( 78.0, 120.0, 0.0);
- points[3] = Vector3( 93.0, 104.0, 0.0);
- PathConstrainer.SetProperty( Dali::PathConstrainer::Property::CONTROL_POINTS, points );
+ points[0] = Vector3(39.0, 90.0, 0.0);
+ points[1] = Vector3(56.0, 119.0, 0.0);
+ points[2] = Vector3(78.0, 120.0, 0.0);
+ points[3] = Vector3(93.0, 104.0, 0.0);
+ PathConstrainer.SetProperty(Dali::PathConstrainer::Property::CONTROL_POINTS, points);
}
-static void SetupLinearConstrainerUniformProgress( Dali::LinearConstrainer& linearConstrainer)
+static void SetupLinearConstrainerUniformProgress(Dali::LinearConstrainer& linearConstrainer)
{
Dali::Property::Array points;
points.Resize(3);
points[0] = 0.0f;
points[1] = 1.0f;
points[2] = 0.0f;
- linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
+ linearConstrainer.SetProperty(Dali::LinearConstrainer::Property::VALUE, points);
}
-static void VerifyLinearConstrainerUniformProgress( Dali::LinearConstrainer& linearConstrainer )
+static void VerifyLinearConstrainerUniformProgress(Dali::LinearConstrainer& linearConstrainer)
{
Dali::Property::Array points;
points.Resize(3);
points[1] = 1.0f;
points[2] = 0.0f;
- Property::Value value = linearConstrainer.GetProperty( Dali::LinearConstrainer::Property::VALUE );
+ Property::Value value = linearConstrainer.GetProperty(Dali::LinearConstrainer::Property::VALUE);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< float >(), points[i].Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<float>(), points[i].Get<float>(), TEST_LOCATION);
}
}
-static void SetupLinearConstrainerNonUniformProgress( Dali::LinearConstrainer& linearConstrainer)
+static void SetupLinearConstrainerNonUniformProgress(Dali::LinearConstrainer& linearConstrainer)
{
Dali::Property::Array points;
points.Resize(3);
points[0] = 0.0f;
points[1] = 1.0f;
points[2] = 0.0f;
- linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
+ linearConstrainer.SetProperty(Dali::LinearConstrainer::Property::VALUE, points);
points[0] = 0.0f;
points[1] = 0.25f;
points[2] = 1.0f;
- linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::PROGRESS, points );
+ linearConstrainer.SetProperty(Dali::LinearConstrainer::Property::PROGRESS, points);
}
} // anonymous namespace
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
//Create a PathConstrainer
Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
- SetupPathConstrainer( pathConstrainer );
+ SetupPathConstrainer(pathConstrainer);
//Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 0.0f, 1.0f );
- pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+ Vector2 range(0.0f, 1.0f);
+ pathConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION), Property(actor, index), range);
//Create an animation to animate the custom property
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Dali::Animation animation = Dali::Animation::New(durationSeconds);
- animation.AnimateTo(Dali::Property(actor,index),1.0f);
+ animation.AnimateTo(Dali::Property(actor, index), 1.0f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 20% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 20% progress */);
Vector3 position, tangent;
- path.Sample(0.2f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ path.Sample(0.2f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 40% progress */);
- path.Sample(0.4f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 40% progress */);
+ path.Sample(0.4f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 60% progress */);
- path.Sample(0.6f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 60% progress */);
+ path.Sample(0.6f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 80% progress */);
- path.Sample(0.8f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 80% progress */);
+ path.Sample(0.8f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* 100% progress */);
- path.Sample(1.0f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* 100% progress */);
+ path.Sample(1.0f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*200.0f)/* beyond the animation duration*/);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 200.0f) /* beyond the animation duration*/);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
//Create a Path
//Create a PathConstrainer
Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
- SetupPathConstrainer( pathConstrainer );
+ SetupPathConstrainer(pathConstrainer);
//Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 100.0f, 300.0f );
- pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
-
+ Vector2 range(100.0f, 300.0f);
+ pathConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION), Property(actor, index), range);
//Create an animation to animate the custom property
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Dali::Animation animation = Dali::Animation::New(durationSeconds);
- animation.AnimateTo(Dali::Property(actor,index),400.0f);
+ animation.AnimateTo(Dali::Property(actor, index), 400.0f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
-
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
Vector3 position, tangent;
- float tValue;
- actor.GetCurrentProperty( index ).Get(tValue);
- float currentCursor = ( tValue - range.x ) / (range.y-range.x);
- path.Sample(currentCursor, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ float tValue;
+ actor.GetCurrentProperty(index).Get(tValue);
+ float currentCursor = (tValue - range.x) / (range.y - range.x);
+ path.Sample(currentCursor, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
- actor.GetCurrentProperty( index ).Get(tValue);
- currentCursor = ( tValue - range.x ) / (range.y-range.x);
- path.Sample(currentCursor, position, tangent );
- path.Sample(0.5, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
+ actor.GetCurrentProperty(index).Get(tValue);
+ currentCursor = (tValue - range.x) / (range.y - range.x);
+ path.Sample(currentCursor, position, tangent);
+ path.Sample(0.5, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
- actor.GetCurrentProperty( index ).Get( tValue );
- currentCursor = ( tValue - range.x ) / (range.y-range.x);
- path.Sample(currentCursor, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
+ actor.GetCurrentProperty(index).Get(tValue);
+ currentCursor = (tValue - range.x) / (range.y - range.x);
+ path.Sample(currentCursor, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
- actor.GetCurrentProperty( index ).Get( tValue );
- currentCursor = ( tValue - range.x ) / (range.y-range.x);
- path.Sample(currentCursor, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% progress */);
+ actor.GetCurrentProperty(index).Get(tValue);
+ currentCursor = (tValue - range.x) / (range.y - range.x);
+ path.Sample(currentCursor, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
- actor.GetCurrentProperty( index ).Get( tValue );
- currentCursor = ( tValue - range.x ) / (range.y-range.x);
- path.Sample(currentCursor, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* beyond the animation duration*/);
+ actor.GetCurrentProperty(index).Get(tValue);
+ currentCursor = (tValue - range.x) / (range.y - range.x);
+ path.Sample(currentCursor, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
// Ensure GetProperty also returns the final result
- actor.GetProperty( index ).Get( tValue );
- currentCursor = ( tValue - range.x ) / (range.y-range.x);
- path.Sample(currentCursor, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ actor.GetProperty(index).Get(tValue);
+ currentCursor = (tValue - range.x) / (range.y - range.x);
+ path.Sample(currentCursor, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
{
//Create a PathConstrainer
Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
- SetupPathConstrainer( pathConstrainer );
+ SetupPathConstrainer(pathConstrainer);
//Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 0.0f, 1.0f );
- pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+ Vector2 range(0.0f, 1.0f);
+ pathConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION), Property(actor, index), range);
//Test that the constraint is correctly applied
- actor.SetProperty(index,0.5f);
+ actor.SetProperty(index, 0.5f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
Vector3 position, tangent;
- path.Sample(0.5f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
-
+ path.Sample(0.5f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
}
//PathConstrainer has been destroyed. Constraint in the actor should have been removed
- actor.SetProperty(index,0.75f);
+ actor.SetProperty(index, 0.75f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
//Create a Path
//Create a PathConstrainer
Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
- SetupPathConstrainer( pathConstrainer );
+ SetupPathConstrainer(pathConstrainer);
//Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 0.0f, 1.0f );
- pathConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION), Property(actor,index), range );
+ Vector2 range(0.0f, 1.0f);
+ pathConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION), Property(actor, index), range);
//Test that the constraint is correctly applied
- actor.SetProperty(index,0.5f);
+ actor.SetProperty(index, 0.5f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
Vector3 position, tangent;
- path.Sample(0.5f, position, tangent );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), position, TEST_LOCATION );
+ path.Sample(0.5f, position, tangent);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), position, TEST_LOCATION);
//Remove constraint
- pathConstrainer.Remove( actor );
- actor.SetProperty(index,0.75f);
+ pathConstrainer.Remove(actor);
+ actor.SetProperty(index, 0.75f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ), Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION), Vector3::ZERO, TEST_LOCATION);
END_TEST;
}
int UtcPathConstrainerProperties(void)
{
- TestApplication application;
+ TestApplication application;
Dali::PathConstrainer pathConstrainer = Dali::PathConstrainer::New();
- pathConstrainer.SetProperty( Dali::PathConstrainer::Property::FORWARD, Vector3( 1.0f,0.0f,0.0f ) );
- DALI_TEST_EQUALS( pathConstrainer.GetProperty< Vector3 >( Dali::PathConstrainer::Property::FORWARD ), Vector3( 1.0f, 0.0f, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( pathConstrainer.GetCurrentProperty< Vector3 >( Dali::PathConstrainer::Property::FORWARD ), Vector3( 1.0f, 0.0f, 0.0f ), TEST_LOCATION );
+ pathConstrainer.SetProperty(Dali::PathConstrainer::Property::FORWARD, Vector3(1.0f, 0.0f, 0.0f));
+ DALI_TEST_EQUALS(pathConstrainer.GetProperty<Vector3>(Dali::PathConstrainer::Property::FORWARD), Vector3(1.0f, 0.0f, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(pathConstrainer.GetCurrentProperty<Vector3>(Dali::PathConstrainer::Property::FORWARD), Vector3(1.0f, 0.0f, 0.0f), TEST_LOCATION);
Dali::Property::Array points;
points.Resize(3);
- points[0] = Vector3( 30.0, 80.0, 0.0);
- points[1] = Vector3( 70.0, 120.0, 0.0);
+ points[0] = Vector3(30.0, 80.0, 0.0);
+ points[1] = Vector3(70.0, 120.0, 0.0);
points[2] = Vector3(100.0, 100.0, 0.0);
- pathConstrainer.SetProperty( Dali::PathConstrainer::Property::POINTS, points );
+ pathConstrainer.SetProperty(Dali::PathConstrainer::Property::POINTS, points);
{
- Property::Value value = pathConstrainer.GetProperty( Dali::PathConstrainer::Property::POINTS );
+ Property::Value value = pathConstrainer.GetProperty(Dali::PathConstrainer::Property::POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
{
- Property::Value value = pathConstrainer.GetCurrentProperty( Dali::PathConstrainer::Property::POINTS );
+ Property::Value value = pathConstrainer.GetCurrentProperty(Dali::PathConstrainer::Property::POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
points.Resize(4);
- points[0] = Vector3( 39.0, 90.0, 0.0);
- points[1] = Vector3( 56.0, 119.0, 0.0);
- points[2] = Vector3( 78.0, 120.0, 0.0);
- points[3] = Vector3( 93.0, 104.0, 0.0);
- pathConstrainer.SetProperty( Dali::PathConstrainer::Property::CONTROL_POINTS, points );
+ points[0] = Vector3(39.0, 90.0, 0.0);
+ points[1] = Vector3(56.0, 119.0, 0.0);
+ points[2] = Vector3(78.0, 120.0, 0.0);
+ points[3] = Vector3(93.0, 104.0, 0.0);
+ pathConstrainer.SetProperty(Dali::PathConstrainer::Property::CONTROL_POINTS, points);
{
- Property::Value value = pathConstrainer.GetProperty( Dali::PathConstrainer::Property::CONTROL_POINTS );
+ Property::Value value = pathConstrainer.GetProperty(Dali::PathConstrainer::Property::CONTROL_POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
{
- Property::Value value = pathConstrainer.GetCurrentProperty( Dali::PathConstrainer::Property::CONTROL_POINTS );
+ Property::Value value = pathConstrainer.GetCurrentProperty(Dali::PathConstrainer::Property::CONTROL_POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
//LinearConstrainer test cases
int UtcLinearConstrainerDownCast(void)
{
- TestApplication application;
+ TestApplication application;
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- BaseHandle handle( linearConstrainer );
- Dali::LinearConstrainer linearConstrainer2 = Dali::LinearConstrainer::DownCast( handle );
- DALI_TEST_EQUALS( (bool)linearConstrainer2, true, TEST_LOCATION );
+ BaseHandle handle(linearConstrainer);
+ Dali::LinearConstrainer linearConstrainer2 = Dali::LinearConstrainer::DownCast(handle);
+ DALI_TEST_EQUALS((bool)linearConstrainer2, true, TEST_LOCATION);
- BaseHandle handle2;
- Dali:: LinearConstrainer linearConstrainer3 = Dali::LinearConstrainer::DownCast( handle2 );
- DALI_TEST_EQUALS( (bool)linearConstrainer3, false, TEST_LOCATION );
+ BaseHandle handle2;
+ Dali::LinearConstrainer linearConstrainer3 = Dali::LinearConstrainer::DownCast(handle2);
+ DALI_TEST_EQUALS((bool)linearConstrainer3, false, TEST_LOCATION);
END_TEST;
}
int UtcLinearConstrainerCopyConstructor(void)
{
- TestApplication application;
+ TestApplication application;
Dali::LinearConstrainer linearConstrainer;
- DALI_TEST_EQUALS( (bool)linearConstrainer, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)linearConstrainer, false, TEST_LOCATION);
linearConstrainer = Dali::LinearConstrainer::New();
- DALI_TEST_EQUALS( (bool)linearConstrainer, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)linearConstrainer, true, TEST_LOCATION);
// call the copy constructor
- Dali::LinearConstrainer linearConstrainer2( linearConstrainer );
- DALI_TEST_EQUALS( (bool)linearConstrainer2, true, TEST_LOCATION );
+ Dali::LinearConstrainer linearConstrainer2(linearConstrainer);
+ DALI_TEST_EQUALS((bool)linearConstrainer2, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- DALI_TEST_CHECK( linearConstrainer );
- DALI_TEST_EQUALS( 1, linearConstrainer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(linearConstrainer);
+ DALI_TEST_EQUALS(1, linearConstrainer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- SetupLinearConstrainerUniformProgress( linearConstrainer );
- VerifyLinearConstrainerUniformProgress( linearConstrainer );
+ SetupLinearConstrainerUniformProgress(linearConstrainer);
+ VerifyLinearConstrainerUniformProgress(linearConstrainer);
- Dali::LinearConstrainer moved = std::move( linearConstrainer );
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- VerifyLinearConstrainerUniformProgress( moved );
- DALI_TEST_CHECK( !linearConstrainer );
+ Dali::LinearConstrainer moved = std::move(linearConstrainer);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ VerifyLinearConstrainerUniformProgress(moved);
+ DALI_TEST_CHECK(!linearConstrainer);
END_TEST;
}
TestApplication application;
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- DALI_TEST_CHECK( linearConstrainer );
- DALI_TEST_EQUALS( 1, linearConstrainer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(linearConstrainer);
+ DALI_TEST_EQUALS(1, linearConstrainer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- SetupLinearConstrainerUniformProgress( linearConstrainer );
- VerifyLinearConstrainerUniformProgress( linearConstrainer );
+ SetupLinearConstrainerUniformProgress(linearConstrainer);
+ VerifyLinearConstrainerUniformProgress(linearConstrainer);
Dali::LinearConstrainer moved;
- moved = std::move( linearConstrainer );
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- VerifyLinearConstrainerUniformProgress( moved );
- DALI_TEST_CHECK( !linearConstrainer );
+ moved = std::move(linearConstrainer);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ VerifyLinearConstrainerUniformProgress(moved);
+ DALI_TEST_CHECK(!linearConstrainer);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
-
//Create a LinearConstrainer without specifying progress for values
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- SetupLinearConstrainerUniformProgress( linearConstrainer );
+ SetupLinearConstrainerUniformProgress(linearConstrainer);
//Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 0.0f, 1.0f );
- linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+ Vector2 range(0.0f, 1.0f);
+ linearConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION_X), Property(actor, index), range);
//Create an animation to animate the custom property
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Dali::Animation animation = Dali::Animation::New(durationSeconds);
- animation.AnimateTo(Dali::Property(actor,index),1.0f);
+ animation.AnimateTo(Dali::Property(actor, index), 1.0f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.5f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 1.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 1.0f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.5f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.5f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* beyond the animation duration*/);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
//Setup a LinearConstrainer specifying the progress for each value
linearConstrainer.Remove(actor);
- SetupLinearConstrainerNonUniformProgress( linearConstrainer );
- linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+ SetupLinearConstrainerNonUniformProgress(linearConstrainer);
+ linearConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION_X), Property(actor, index), range);
- actor.SetProperty(index,0.0f);
+ actor.SetProperty(index, 0.0f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 1.0f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 2.0f/3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 2.0f / 3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 1.0f/3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 1.0f / 3.0f, Math::MACHINE_EPSILON_1, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* beyond the animation duration*/);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 100.0f );
+ Property::Index index = actor.RegisterProperty("t", 100.0f);
application.GetScene().Add(actor);
//Create a LinearConstrainer
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- SetupLinearConstrainerUniformProgress( linearConstrainer );
+ SetupLinearConstrainerUniformProgress(linearConstrainer);
//Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 100.0f, 300.0f );
- linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
-
+ Vector2 range(100.0f, 300.0f);
+ linearConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION_X), Property(actor, index), range);
//Create an animation to animate the custom property
- float durationSeconds(1.0f);
+ float durationSeconds(1.0f);
Dali::Animation animation = Dali::Animation::New(durationSeconds);
- animation.AnimateTo(Dali::Property(actor,index),300.0f);
+ animation.AnimateTo(Dali::Property(actor, index), 300.0f);
animation.Play();
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 25% progress */);
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 25% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.5f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 50% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 1.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 50% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 1.0f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 75% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.5f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 75% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.5f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* 100% progress */);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* 100% progress */);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
application.SendNotification();
- application.Render(static_cast<unsigned int>(durationSeconds*250.0f)/* beyond the animation duration*/);
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ application.Render(static_cast<unsigned int>(durationSeconds * 250.0f) /* beyond the animation duration*/);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
{
//Create a LinearConstrainer
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- SetupLinearConstrainerUniformProgress( linearConstrainer );
+ SetupLinearConstrainerUniformProgress(linearConstrainer);
//Apply the linear constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 0.0f, 1.0f );
- linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+ Vector2 range(0.0f, 1.0f);
+ linearConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION_X), Property(actor, index), range);
//Test that the constraint is correctly applied
- actor.SetProperty(index,0.5f);
+ actor.SetProperty(index, 0.5f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 1.0f, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 1.0f, TEST_LOCATION);
}
//LinearConstrainer has been destroyed. Constraint in the actor should have been removed
- actor.SetProperty(index,0.75f);
+ actor.SetProperty(index, 0.75f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
END_TEST;
}
Dali::Actor actor = Dali::Actor::New();
// Register a float property
- Property::Index index = actor.RegisterProperty( "t", 0.0f );
+ Property::Index index = actor.RegisterProperty("t", 0.0f);
application.GetScene().Add(actor);
//Create a LinearConstrainer
Dali::LinearConstrainer linearConstrainer = Dali::LinearConstrainer::New();
- SetupLinearConstrainerUniformProgress( linearConstrainer );
+ SetupLinearConstrainerUniformProgress(linearConstrainer);
//Apply the path constraint to the actor's position. The source property for the constraint will be the custom property "t"
- Vector2 range( 0.0f, 1.0f );
- linearConstrainer.Apply( Property(actor,Dali::Actor::Property::POSITION_X), Property(actor,index), range );
+ Vector2 range(0.0f, 1.0f);
+ linearConstrainer.Apply(Property(actor, Dali::Actor::Property::POSITION_X), Property(actor, index), range);
//Test that the constraint is correctly applied
- actor.SetProperty(index,0.5f);
+ actor.SetProperty(index, 0.5f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 1.0f, TEST_LOCATION);
//Remove constraint
- linearConstrainer.Remove( actor );
- actor.SetProperty(index,0.75f);
+ linearConstrainer.Remove(actor);
+ actor.SetProperty(index, 0.75f);
application.SendNotification();
application.Render(static_cast<unsigned int>(1.0f));
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Dali::Actor::Property::POSITION ).x, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Dali::Actor::Property::POSITION).x, 0.0f, TEST_LOCATION);
END_TEST;
}
points[0] = 0.0f;
points[1] = 1.0f;
points[2] = 0.0f;
- linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::VALUE, points );
+ linearConstrainer.SetProperty(Dali::LinearConstrainer::Property::VALUE, points);
{
- Property::Value value = linearConstrainer.GetProperty( Dali::LinearConstrainer::Property::VALUE );
+ Property::Value value = linearConstrainer.GetProperty(Dali::LinearConstrainer::Property::VALUE);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< float >(), points[i].Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<float>(), points[i].Get<float>(), TEST_LOCATION);
}
}
{
- Property::Value value = linearConstrainer.GetCurrentProperty( Dali::LinearConstrainer::Property::VALUE );
+ Property::Value value = linearConstrainer.GetCurrentProperty(Dali::LinearConstrainer::Property::VALUE);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
points[0] = 0.0f;
points[1] = 0.25f;
points[2] = 1.0f;
- linearConstrainer.SetProperty( Dali::LinearConstrainer::Property::PROGRESS, points );
+ linearConstrainer.SetProperty(Dali::LinearConstrainer::Property::PROGRESS, points);
{
- Property::Value value = linearConstrainer.GetProperty( Dali::LinearConstrainer::Property::PROGRESS );
+ Property::Value value = linearConstrainer.GetProperty(Dali::LinearConstrainer::Property::PROGRESS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< float >(), points[i].Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<float>(), points[i].Get<float>(), TEST_LOCATION);
}
}
{
- Property::Value value = linearConstrainer.GetCurrentProperty( Dali::LinearConstrainer::Property::PROGRESS );
+ Property::Value value = linearConstrainer.GetCurrentProperty(Dali::LinearConstrainer::Property::PROGRESS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< float >(), points[i].Get< float >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<float>(), points[i].Get<float>(), TEST_LOCATION);
}
}
Dali::LinearConstrainer constrainer = Dali::LinearConstrainer::New();
- Property::Index index = constrainer.RegisterProperty( "sceneProperty", 0 );
- DALI_TEST_EQUALS( index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( constrainer.GetProperty< int32_t >( index ), 0, TEST_LOCATION );
+ Property::Index index = constrainer.RegisterProperty("sceneProperty", 0);
+ DALI_TEST_EQUALS(index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(constrainer.GetProperty<int32_t>(index), 0, TEST_LOCATION);
- constrainer.SetProperty( index, -123 );
- DALI_TEST_EQUALS( constrainer.GetProperty< int32_t >( index ), -123, TEST_LOCATION );
+ constrainer.SetProperty(index, -123);
+ DALI_TEST_EQUALS(constrainer.GetProperty<int32_t>(index), -123, TEST_LOCATION);
using Dali::Animation;
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( constrainer, index ), 99 );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(constrainer, index), 99);
- DALI_TEST_EQUALS( constrainer.GetProperty< int32_t >( index ), -123, TEST_LOCATION );
+ DALI_TEST_EQUALS(constrainer.GetProperty<int32_t>(index), -123, TEST_LOCATION);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( 1000 /* 100% progress */);
- DALI_TEST_EQUALS( constrainer.GetProperty< int32_t >( index ), 99, TEST_LOCATION );
+ application.Render(1000 /* 100% progress */);
+ DALI_TEST_EQUALS(constrainer.GetProperty<int32_t>(index), 99, TEST_LOCATION);
END_TEST;
}
Dali::PathConstrainer constrainer = Dali::PathConstrainer::New();
- Property::Index index = constrainer.RegisterProperty( "pathProperty", Vector2() );
- DALI_TEST_EQUALS( index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( constrainer.GetProperty< Vector2 >( index ), Vector2(), TEST_LOCATION );
+ Property::Index index = constrainer.RegisterProperty("pathProperty", Vector2());
+ DALI_TEST_EQUALS(index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(constrainer.GetProperty<Vector2>(index), Vector2(), TEST_LOCATION);
- constrainer.SetProperty( index, Vector2(1,2) );
- DALI_TEST_EQUALS( constrainer.GetProperty< Vector2 >( index ), Vector2(1,2), TEST_LOCATION );
+ constrainer.SetProperty(index, Vector2(1, 2));
+ DALI_TEST_EQUALS(constrainer.GetProperty<Vector2>(index), Vector2(1, 2), TEST_LOCATION);
using Dali::Animation;
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( constrainer, index ), Vector2(3,4) );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(constrainer, index), Vector2(3, 4));
- DALI_TEST_EQUALS( constrainer.GetProperty< Vector2 >( index ), Vector2(1,2), TEST_LOCATION );
+ DALI_TEST_EQUALS(constrainer.GetProperty<Vector2>(index), Vector2(1, 2), TEST_LOCATION);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( 1000 /* 100% progress */);
- DALI_TEST_EQUALS( constrainer.GetProperty< Vector2 >( index ), Vector2(3,4), TEST_LOCATION );
+ application.Render(1000 /* 100% progress */);
+ DALI_TEST_EQUALS(constrainer.GetProperty<Vector2>(index), Vector2(3, 4), TEST_LOCATION);
END_TEST;
}
int UtcDaliLinearConstrainerApplyNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::LinearConstrainer instance;
- Dali::Actor actor;
+ Dali::Actor actor;
try
{
Dali::Property arg1(actor, Dali::Actor::Property::POSITION);
Dali::Property arg2(actor, Dali::Actor::Property::POSITION);
- Dali::Vector2 arg3;
- Dali::Vector2 arg4;
- instance.Apply(arg1,arg2,arg3,arg4);
+ Dali::Vector2 arg3;
+ Dali::Vector2 arg4;
+ instance.Apply(arg1, arg2, arg3, arg4);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliLinearConstrainerRemoveNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::LinearConstrainer instance;
try
{
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
/**
* A function to use for a constraint, no data collected.
*/
-template< typename T >
-void BasicFunction( T& /* current */, const PropertyInputContainer& /* inputs */ )
+template<typename T>
+void BasicFunction(T& /* current */, const PropertyInputContainer& /* inputs */)
{
}
/**
* A functor which sets a given boolean when the functor is called.
*/
-template< typename T >
+template<typename T>
struct BasicCalledFunctor
{
- BasicCalledFunctor( bool& functorCalled ) : mCalled( functorCalled ) { }
+ BasicCalledFunctor(bool& functorCalled)
+ : mCalled(functorCalled)
+ {
+ }
- void operator()( T& /* current */, const PropertyInputContainer& /* inputs */ )
+ void operator()(T& /* current */, const PropertyInputContainer& /* inputs */)
{
mCalled = true;
}
/**
* A functor which increments a given integer when the functor is called.
*/
-template< typename T >
+template<typename T>
struct CalledCountFunctor
{
- CalledCountFunctor( int& callCount ) : mCallCount( callCount ) { }
+ CalledCountFunctor(int& callCount)
+ : mCallCount(callCount)
+ {
+ }
- void operator()( T& /* current */, const PropertyInputContainer& /* inputs */ )
+ void operator()(T& /* current */, const PropertyInputContainer& /* inputs */)
{
++mCallCount;
}
/**
* A functor which sets the given value as the value required when the functor is called.
*/
-template< typename T >
+template<typename T>
struct SetValueFunctor
{
- SetValueFunctor( const T& value ) : mValue( value ) { }
+ SetValueFunctor(const T& value)
+ : mValue(value)
+ {
+ }
- void operator()( T& current, const PropertyInputContainer& /* inputs */ )
+ void operator()(T& current, const PropertyInputContainer& /* inputs */)
{
current = mValue;
}
namespace UtcDaliConstraintNewFunction
{
bool gConstraintFunctionCalled = false;
-void ConstraintFunction( Vector3& /* current */, const PropertyInputContainer& /* inputs */ )
+void ConstraintFunction(Vector3& /* current */, const PropertyInputContainer& /* inputs */)
{
gConstraintFunctionCalled = true;
}
UtcDaliConstraintNewFunction::gConstraintFunctionCalled = false;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( UtcDaliConstraintNewFunction::gConstraintFunctionCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(UtcDaliConstraintNewFunction::gConstraintFunctionCalled, false, TEST_LOCATION);
// Add a constraint
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &UtcDaliConstraintNewFunction::ConstraintFunction );
- DALI_TEST_CHECK( constraint );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &UtcDaliConstraintNewFunction::ConstraintFunction);
+ DALI_TEST_CHECK(constraint);
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( UtcDaliConstraintNewFunction::gConstraintFunctionCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(UtcDaliConstraintNewFunction::gConstraintFunctionCalled, true, TEST_LOCATION);
END_TEST;
}
// Add a constraint with an uninitialised handle
try
{
- Constraint constraint = Constraint::New< Vector3 >( Actor(), Actor::Property::POSITION, &UtcDaliConstraintNewFunction::ConstraintFunction );
- DALI_TEST_CHECK( false ); // Should not reach here
+ Constraint constraint = Constraint::New<Vector3>(Actor(), Actor::Property::POSITION, &UtcDaliConstraintNewFunction::ConstraintFunction);
+ DALI_TEST_CHECK(false); // Should not reach here
}
- catch ( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true ); // Should assert!
+ DALI_TEST_CHECK(true); // Should assert!
}
END_TEST;
}
// helper for next test
-void StringConstraintFunction( std::string& /* current */, const PropertyInputContainer& /* inputs */ )
+void StringConstraintFunction(std::string& /* current */, const PropertyInputContainer& /* inputs */)
{
}
UtcDaliConstraintNewFunction::gConstraintFunctionCalled = false;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
try
{
// Add a constraint
- Constraint constraint = Constraint::New< std::string >( actor, Actor::Property::COLOR_MODE, &StringConstraintFunction );
- DALI_TEST_CHECK( constraint );
+ Constraint constraint = Constraint::New<std::string>(actor, Actor::Property::COLOR_MODE, &StringConstraintFunction);
+ DALI_TEST_CHECK(constraint);
constraint.Apply();
tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property not constrainable", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property not constrainable", TEST_LOCATION);
}
END_TEST;
// Ensure that we can create a constraint using a functor and that it is called.
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Add a constraint
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, BasicCalledFunctor< Vector3 >( functorCalled ) );
- DALI_TEST_CHECK( constraint );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, BasicCalledFunctor<Vector3>(functorCalled));
+ DALI_TEST_CHECK(constraint);
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
END_TEST;
}
// Create a constraint with an uninitialised handle
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
// Add a constraint with an uninitialised handle
try
{
- Constraint constraint = Constraint::New< Vector3 >( Actor(), Actor::Property::POSITION, BasicCalledFunctor< Vector3 >( functorCalled ) );
- DALI_TEST_CHECK( false ); // Should not reach here
+ Constraint constraint = Constraint::New<Vector3>(Actor(), Actor::Property::POSITION, BasicCalledFunctor<Vector3>(functorCalled));
+ DALI_TEST_CHECK(false); // Should not reach here
}
- catch ( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true ); // Should assert!
+ DALI_TEST_CHECK(true); // Should assert!
}
END_TEST;
{
struct Functor
{
- Functor( bool& positionCalled, bool& scaleCalled )
- : mPositionCalled( positionCalled ),
- mScaleCalled( scaleCalled )
+ Functor(bool& positionCalled, bool& scaleCalled)
+ : mPositionCalled(positionCalled),
+ mScaleCalled(scaleCalled)
{
}
- void Position( Vector3& /* current */, const PropertyInputContainer& /* inputs */ )
+ void Position(Vector3& /* current */, const PropertyInputContainer& /* inputs */)
{
mPositionCalled = true;
}
- void Scale( Vector3& /* current */, const PropertyInputContainer& /* inputs */ )
+ void Scale(Vector3& /* current */, const PropertyInputContainer& /* inputs */)
{
mScaleCalled = true;
}
// Ensure that we can create a constraint using a functor and that it is called.
TestApplication application;
- bool positionFunctorCalled = false;
- bool sizeFunctorCalled = false;
+ bool positionFunctorCalled = false;
+ bool sizeFunctorCalled = false;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( positionFunctorCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( sizeFunctorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(positionFunctorCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(sizeFunctorCalled, false, TEST_LOCATION);
// Add a constraint that calls Functor::Position
- Constraint constraint = Constraint::New< Vector3 >(
- actor,
- Actor::Property::POSITION,
- UtcDaliConstraintNewFunctorMember::Functor( positionFunctorCalled, sizeFunctorCalled ),
- &UtcDaliConstraintNewFunctorMember::Functor::Position );
- DALI_TEST_CHECK( constraint );
+ Constraint constraint = Constraint::New<Vector3>(
+ actor,
+ Actor::Property::POSITION,
+ UtcDaliConstraintNewFunctorMember::Functor(positionFunctorCalled, sizeFunctorCalled),
+ &UtcDaliConstraintNewFunctorMember::Functor::Position);
+ DALI_TEST_CHECK(constraint);
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( positionFunctorCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( sizeFunctorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(positionFunctorCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(sizeFunctorCalled, false, TEST_LOCATION);
// Add another constraint that calls Functor::Size
- Constraint constraint2 = Constraint::New< Vector3 >(
- actor,
- Actor::Property::SCALE,
- UtcDaliConstraintNewFunctorMember::Functor( positionFunctorCalled, sizeFunctorCalled ),
- &UtcDaliConstraintNewFunctorMember::Functor::Scale );
- DALI_TEST_CHECK( constraint2 );
+ Constraint constraint2 = Constraint::New<Vector3>(
+ actor,
+ Actor::Property::SCALE,
+ UtcDaliConstraintNewFunctorMember::Functor(positionFunctorCalled, sizeFunctorCalled),
+ &UtcDaliConstraintNewFunctorMember::Functor::Scale);
+ DALI_TEST_CHECK(constraint2);
constraint2.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( positionFunctorCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( sizeFunctorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(positionFunctorCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(sizeFunctorCalled, true, TEST_LOCATION);
END_TEST;
}
// Create a constraint with an uninitialised handle
TestApplication application;
- bool positionFunctorCalled = false;
- bool sizeFunctorCalled = false;
+ bool positionFunctorCalled = false;
+ bool sizeFunctorCalled = false;
// Add a constraint with an uninitialised handle
try
{
- Constraint constraint = Constraint::New< Vector3 >(
- Actor(),
- Actor::Property::POSITION,
- UtcDaliConstraintNewFunctorMember::Functor( positionFunctorCalled, sizeFunctorCalled ),
- &UtcDaliConstraintNewFunctorMember::Functor::Position );
- DALI_TEST_CHECK( false ); // Should not reach here
+ Constraint constraint = Constraint::New<Vector3>(
+ Actor(),
+ Actor::Property::POSITION,
+ UtcDaliConstraintNewFunctorMember::Functor(positionFunctorCalled, sizeFunctorCalled),
+ &UtcDaliConstraintNewFunctorMember::Functor::Position);
+ DALI_TEST_CHECK(false); // Should not reach here
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_CHECK( true ); // Should assert!
+ DALI_TEST_CHECK(true); // Should assert!
}
END_TEST;
// Ensure we can clone for another actor and it's called appropriately
TestApplication application;
- int calledCount = 0;
+ int calledCount = 0;
Actor actor = Actor::New();
Actor clone = Actor::New();
Integration::Scene stage = application.GetScene();
- stage.Add( actor );
- stage.Add( clone );
+ stage.Add(actor);
+ stage.Add(clone);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( calledCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(calledCount, 0, TEST_LOCATION);
// Add a constraint to actor
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, CalledCountFunctor< Vector3 >( calledCount ) );
- DALI_TEST_CHECK( constraint );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, CalledCountFunctor<Vector3>(calledCount));
+ DALI_TEST_CHECK(constraint);
constraint.Apply();
// Create a clone but don't apply
- Constraint constraintClone = constraint.Clone( clone );
+ Constraint constraintClone = constraint.Clone(clone);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( calledCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(calledCount, 1, TEST_LOCATION);
// Reset
calledCount = 0;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( calledCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(calledCount, 1, TEST_LOCATION);
// Apply the clone constraint
constraintClone.Apply();
application.Render();
// Should be called once for the new constraint clone and once for the original constraint
- DALI_TEST_EQUALS( calledCount, 3, TEST_LOCATION );
+ DALI_TEST_EQUALS(calledCount, 3, TEST_LOCATION);
// Reset
calledCount = 0;
// Change the position of both actors
- actor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- clone.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ clone.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
application.SendNotification();
application.Render();
// Functor should have been called twice
- DALI_TEST_EQUALS( calledCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(calledCount, 2, TEST_LOCATION);
END_TEST;
}
try
{
- Actor actor = Actor::New();
- Constraint clone = constraint.Clone( actor );
- DALI_TEST_CHECK( false );
+ Actor actor = Actor::New();
+ Constraint clone = constraint.Clone(actor);
+ DALI_TEST_CHECK(false);
}
- catch ( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
namespace UtcDaliConstraintClone
{
-void Function( Vector3& /* current */, const PropertyInputContainer& inputs )
+void Function(Vector3& /* current */, const PropertyInputContainer& inputs)
{
- DALI_TEST_EQUALS( inputs[0]->GetType(), Property::VECTOR3, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[1]->GetType(), Property::ROTATION, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[2]->GetType(), Property::VECTOR4, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[3]->GetType(), Property::BOOLEAN, TEST_LOCATION );
+ DALI_TEST_EQUALS(inputs[0]->GetType(), Property::VECTOR3, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[1]->GetType(), Property::ROTATION, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[2]->GetType(), Property::VECTOR4, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[3]->GetType(), Property::BOOLEAN, TEST_LOCATION);
}
} // namespace UtcDaliConstraintClone
Actor clone = Actor::New();
Integration::Scene stage = application.GetScene();
- stage.Add( actor );
- stage.Add( clone );
+ stage.Add(actor);
+ stage.Add(clone);
application.SendNotification();
application.Render();
// Create a constraint, DON'T Apply it though
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &UtcDaliConstraintClone::Function );
- constraint.AddSource( LocalSource( Actor::Property::SIZE ) );
- constraint.AddSource( LocalSource( Actor::Property::ORIENTATION ) );
- constraint.AddSource( LocalSource( Actor::Property::COLOR ) );
- constraint.AddSource( LocalSource( Actor::Property::VISIBLE ) );
- constraint.SetRemoveAction( Constraint::DISCARD );
- constraint.SetTag( 123 );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &UtcDaliConstraintClone::Function);
+ constraint.AddSource(LocalSource(Actor::Property::SIZE));
+ constraint.AddSource(LocalSource(Actor::Property::ORIENTATION));
+ constraint.AddSource(LocalSource(Actor::Property::COLOR));
+ constraint.AddSource(LocalSource(Actor::Property::VISIBLE));
+ constraint.SetRemoveAction(Constraint::DISCARD);
+ constraint.SetTag(123);
// Clone the constraint & apply the clone
- Constraint constraintClone = constraint.Clone( clone );
+ Constraint constraintClone = constraint.Clone(clone);
constraintClone.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( constraint.GetRemoveAction(), constraintClone.GetRemoveAction(), TEST_LOCATION );
- DALI_TEST_EQUALS( constraint.GetTag(), constraintClone.GetTag(), TEST_LOCATION );
+ DALI_TEST_EQUALS(constraint.GetRemoveAction(), constraintClone.GetRemoveAction(), TEST_LOCATION);
+ DALI_TEST_EQUALS(constraint.GetTag(), constraintClone.GetTag(), TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- Constraint copied( constraint );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ Constraint copied(constraint);
Constraint assigned;
- DALI_TEST_CHECK( constraint == copied );
- DALI_TEST_CHECK( copied != assigned );
+ DALI_TEST_CHECK(constraint == copied);
+ DALI_TEST_CHECK(copied != assigned);
assigned = constraint;
- DALI_TEST_CHECK( constraint == assigned );
+ DALI_TEST_CHECK(constraint == assigned);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- DALI_TEST_CHECK( constraint );
- DALI_TEST_EQUALS( 1, constraint.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( constraint.GetTargetObject() == actor );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ DALI_TEST_CHECK(constraint);
+ DALI_TEST_EQUALS(1, constraint.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(constraint.GetTargetObject() == actor);
- Constraint moved = std::move( constraint );
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( moved.GetTargetObject() == actor );
- DALI_TEST_CHECK( !constraint );
+ Constraint moved = std::move(constraint);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(moved.GetTargetObject() == actor);
+ DALI_TEST_CHECK(!constraint);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- DALI_TEST_CHECK( constraint );
- DALI_TEST_EQUALS( 1, constraint.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( constraint.GetTargetObject() == actor );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ DALI_TEST_CHECK(constraint);
+ DALI_TEST_EQUALS(1, constraint.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(constraint.GetTargetObject() == actor);
Constraint moved;
- moved = std::move( constraint );
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( moved.GetTargetObject() == actor );
- DALI_TEST_CHECK( !constraint );
+ moved = std::move(constraint);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(moved.GetTargetObject() == actor);
+ DALI_TEST_CHECK(!constraint);
END_TEST;
}
TestApplication application;
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
// Another BaseHandle type
- Constraint downCast = Constraint::DownCast( actor );
- DALI_TEST_CHECK( ! downCast );
+ Constraint downCast = Constraint::DownCast(actor);
+ DALI_TEST_CHECK(!downCast);
// A constraint
- downCast = Constraint::DownCast( constraint );
- DALI_TEST_CHECK( downCast );
+ downCast = Constraint::DownCast(constraint);
+ DALI_TEST_CHECK(downCast);
// An empty constraint
- downCast = Constraint::DownCast( Constraint() );
- DALI_TEST_CHECK( ! downCast );
+ downCast = Constraint::DownCast(Constraint());
+ DALI_TEST_CHECK(!downCast);
END_TEST;
}
{
TestApplication application;
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- DALI_TEST_CHECK( constraint.GetTargetObject() == actor );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ DALI_TEST_CHECK(constraint.GetTargetObject() == actor);
Actor actor2 = Actor::New();
- DALI_TEST_CHECK( constraint.GetTargetObject() != actor2 );
+ DALI_TEST_CHECK(constraint.GetTargetObject() != actor2);
END_TEST;
}
try
{
Handle handle = constraint.GetTargetObject();
- DALI_TEST_CHECK( false ); // Should not reach here!
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
{
TestApplication application;
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- DALI_TEST_EQUALS( constraint.GetTargetProperty(), (Property::Index)Actor::Property::POSITION, TEST_LOCATION );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ DALI_TEST_EQUALS(constraint.GetTargetProperty(), (Property::Index)Actor::Property::POSITION, TEST_LOCATION);
END_TEST;
}
try
{
Property::Index propertyIndex = constraint.GetTargetProperty();
- ( void )propertyIndex;
- DALI_TEST_CHECK( false ); // Should not reach here!
+ (void)propertyIndex;
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
{
TestApplication application;
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- DALI_TEST_EQUALS( constraint.GetTag(), 0u, TEST_LOCATION );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ DALI_TEST_EQUALS(constraint.GetTag(), 0u, TEST_LOCATION);
const unsigned int tag = 123;
- constraint.SetTag( tag );
- DALI_TEST_EQUALS( constraint.GetTag(), tag, TEST_LOCATION );
+ constraint.SetTag(tag);
+ DALI_TEST_EQUALS(constraint.GetTag(), tag, TEST_LOCATION);
END_TEST;
}
Constraint constraint;
try
{
- constraint.SetTag( 123 );
- DALI_TEST_CHECK( false ); // Should not reach here!
+ constraint.SetTag(123);
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
try
{
int tag = constraint.GetTag();
- ( void )tag;
- DALI_TEST_CHECK( false ); // Should not reach here!
+ (void)tag;
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
{
TestApplication application;
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &BasicFunction< Vector3 > );
- DALI_TEST_EQUALS( constraint.GetRemoveAction(), Constraint::DEFAULT_REMOVE_ACTION, TEST_LOCATION );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &BasicFunction<Vector3>);
+ DALI_TEST_EQUALS(constraint.GetRemoveAction(), Constraint::DEFAULT_REMOVE_ACTION, TEST_LOCATION);
- constraint.SetRemoveAction( Constraint::DISCARD );
- DALI_TEST_EQUALS( constraint.GetRemoveAction(), Constraint::DISCARD, TEST_LOCATION );
+ constraint.SetRemoveAction(Constraint::DISCARD);
+ DALI_TEST_EQUALS(constraint.GetRemoveAction(), Constraint::DISCARD, TEST_LOCATION);
- constraint.SetRemoveAction( Constraint::BAKE );
- DALI_TEST_EQUALS( constraint.GetRemoveAction(), Constraint::BAKE, TEST_LOCATION );
+ constraint.SetRemoveAction(Constraint::BAKE);
+ DALI_TEST_EQUALS(constraint.GetRemoveAction(), Constraint::BAKE, TEST_LOCATION);
END_TEST;
}
Constraint constraint;
try
{
- constraint.SetRemoveAction( Constraint::DISCARD );
- DALI_TEST_CHECK( false ); // Should not reach here!
+ constraint.SetRemoveAction(Constraint::DISCARD);
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
try
{
Constraint::RemoveAction removeAction = constraint.GetRemoveAction();
- ( void )removeAction;
- DALI_TEST_CHECK( false ); // Should not reach here!
+ (void)removeAction;
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
// Should not equal position by default
- Vector3 position( 10.0f, 20.0f, 30.0f );
- DALI_TEST_CHECK( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) != position );
+ Vector3 position(10.0f, 20.0f, 30.0f);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION) != position);
// Create a constraint that constrains to position
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, SetValueFunctor< Vector3 >( position ) );
- constraint.SetRemoveAction( Constraint::BAKE );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, SetValueFunctor<Vector3>(position));
+ constraint.SetRemoveAction(Constraint::BAKE);
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
// Remove the constraint, it should still be at position
constraint.Remove();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
// Get and store current position
- Vector3 originalPosition = actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
+ Vector3 originalPosition = actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION);
// Should not equal position by default
- Vector3 position( 10.0f, 20.0f, 30.0f );
- DALI_TEST_CHECK( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) != position );
+ Vector3 position(10.0f, 20.0f, 30.0f);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION) != position);
// Create a constraint that constrains to position
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, SetValueFunctor< Vector3 >( position ) );
- constraint.SetRemoveAction( Constraint::DISCARD );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, SetValueFunctor<Vector3>(position));
+ constraint.SetRemoveAction(Constraint::DISCARD);
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), position, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), position, TEST_LOCATION);
// Remove the constraint, it should still be at position
constraint.Remove();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), originalPosition, TEST_LOCATION );
- DALI_TEST_CHECK( actor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ) != position );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION), originalPosition, TEST_LOCATION);
+ DALI_TEST_CHECK(actor.GetCurrentProperty<Vector3>(Actor::Property::POSITION) != position);
END_TEST;
}
// Ensure constraint functors are called appropriately
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Create a constraint and apply, functor should be called
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, BasicCalledFunctor< Vector3 >( functorCalled ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, BasicCalledFunctor<Vector3>(functorCalled));
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
// Reset
functorCalled = false;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Re-apply the constraint, functor should be called again
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
END_TEST;
}
// Constraint should be automatically applied when the actor is added to the stage and not before
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
// Create an actor and a constraint and apply, DON'T add to stage just yet
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, BasicCalledFunctor< Vector3 >( functorCalled ) );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, BasicCalledFunctor<Vector3>(functorCalled));
constraint.Apply();
application.SendNotification();
application.Render();
// Should NOT be called
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Add actor to stage
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
// Should now be called
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
END_TEST;
}
// Constraint should NOT be called at all
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
// Create an actor and a constraint and apply, DON'T add to stage just yet
- Actor actor = Actor::New();
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, BasicCalledFunctor< Vector3 >( functorCalled ) );
+ Actor actor = Actor::New();
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, BasicCalledFunctor<Vector3>(functorCalled));
constraint.Apply();
application.SendNotification();
application.Render();
// Should NOT be called
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Remove the constraint
constraint.Remove();
// Add actor to stage
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
// Still should NOT be called
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
END_TEST;
}
// Functor should only be called while the actor is staged.
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
// Create an actor and add to stage
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Integration::Scene stage = application.GetScene();
- stage.Add( actor );
+ stage.Add(actor);
// Create a constraint and apply
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, BasicCalledFunctor< Vector3 >( functorCalled ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, BasicCalledFunctor<Vector3>(functorCalled));
constraint.Apply();
application.SendNotification();
application.Render();
// Constraint should be called
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
// Reset
functorCalled = false;
// Remove actor from stage
- stage.Remove( actor );
+ stage.Remove(actor);
application.SendNotification();
application.Render();
// Constraint should NOT be called
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Re-add to stage
- stage.Add( actor );
+ stage.Add(actor);
application.SendNotification();
application.Render();
// Constraint should be called
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
END_TEST;
}
// Should not cause any problems (subsequent attempts should be no-ops)
TestApplication application;
- int count = 0;
+ int count = 0;
// Create an actor and add to stage
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Integration::Scene stage = application.GetScene();
- stage.Add( actor );
+ stage.Add(actor);
// Create a constraint and apply
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, CalledCountFunctor< Vector3 >( count ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, CalledCountFunctor<Vector3>(count));
constraint.Apply();
// Apply again
application.Render();
// Should only have been called once
- DALI_TEST_EQUALS( count, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(count, 1, TEST_LOCATION);
// Reset
count = 0;
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( count, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(count, 1, TEST_LOCATION);
// Reset
count = 0;
// Change the position property, apply again
- actor.SetProperty( Actor::Property::POSITION, Vector2( 10.0f, 10.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
constraint.Apply();
application.SendNotification();
application.Render();
// Constraint should have been called once
- DALI_TEST_EQUALS( count, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(count, 1, TEST_LOCATION);
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
namespace UtcDaliConstraintAddSource
{
-void Function( Vector3& /* current */, const PropertyInputContainer& inputs )
+void Function(Vector3& /* current */, const PropertyInputContainer& inputs)
{
- DALI_TEST_EQUALS( inputs.Size(), 4u, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[0]->GetType(), Property::VECTOR3, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[1]->GetType(), Property::ROTATION, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[2]->GetType(), Property::VECTOR4, TEST_LOCATION );
- DALI_TEST_EQUALS( inputs[3]->GetType(), Property::BOOLEAN, TEST_LOCATION );
+ DALI_TEST_EQUALS(inputs.Size(), 4u, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[0]->GetType(), Property::VECTOR3, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[1]->GetType(), Property::ROTATION, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[2]->GetType(), Property::VECTOR4, TEST_LOCATION);
+ DALI_TEST_EQUALS(inputs[3]->GetType(), Property::BOOLEAN, TEST_LOCATION);
}
} // namespace UtcDaliConstraintAddSource
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Create a constraint, add sources
- Constraint constraint = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &UtcDaliConstraintAddSource::Function );
- constraint.AddSource( LocalSource( Actor::Property::SIZE ) );
- constraint.AddSource( LocalSource( Actor::Property::ORIENTATION ) );
- constraint.AddSource( LocalSource( Actor::Property::COLOR ) );
- constraint.AddSource( LocalSource( Actor::Property::VISIBLE ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &UtcDaliConstraintAddSource::Function);
+ constraint.AddSource(LocalSource(Actor::Property::SIZE));
+ constraint.AddSource(LocalSource(Actor::Property::ORIENTATION));
+ constraint.AddSource(LocalSource(Actor::Property::COLOR));
+ constraint.AddSource(LocalSource(Actor::Property::VISIBLE));
constraint.Apply();
application.SendNotification();
Constraint constraint;
try
{
- constraint.AddSource( LocalSource( Actor::Property::POSITION ) );
- DALI_TEST_CHECK( false ); // Should not reach here!
+ constraint.AddSource(LocalSource(Actor::Property::POSITION));
+ DALI_TEST_CHECK(false); // Should not reach here!
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
///////////////////////////////////////////////////////////////////////////////
namespace TestChaining
{
-
-const Vector3 gFunction1Output( Vector3::ONE );
-void Function1( Vector3& current, const PropertyInputContainer& /* inputs */ )
+const Vector3 gFunction1Output(Vector3::ONE);
+void Function1(Vector3& current, const PropertyInputContainer& /* inputs */)
{
// current is original position
- DALI_TEST_EQUALS( current, Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(current, Vector3::ZERO, TEST_LOCATION);
current = gFunction1Output;
}
-const Vector3 gFunction2Output( 10.0f, 20.0f, 30.0f );
-void Function2( Vector3& current, const PropertyInputContainer& /* inputs */ )
+const Vector3 gFunction2Output(10.0f, 20.0f, 30.0f);
+void Function2(Vector3& current, const PropertyInputContainer& /* inputs */)
{
// current is output from Function1
- DALI_TEST_EQUALS( current, gFunction1Output, TEST_LOCATION );
+ DALI_TEST_EQUALS(current, gFunction1Output, TEST_LOCATION);
current = gFunction2Output;
}
-const Vector3 gFunction3Output( 10.0f, 20.0f, 30.0f );
-void Function3( Vector3& current, const PropertyInputContainer& /* inputs */ )
+const Vector3 gFunction3Output(10.0f, 20.0f, 30.0f);
+void Function3(Vector3& current, const PropertyInputContainer& /* inputs */)
{
// current is output from Function2
- DALI_TEST_EQUALS( current, gFunction2Output, TEST_LOCATION );
+ DALI_TEST_EQUALS(current, gFunction2Output, TEST_LOCATION);
current = gFunction3Output;
}
-const Vector3 gFunction4Output( 10.0f, 20.0f, 30.0f );
-void Function4( Vector3& current, const PropertyInputContainer& /* inputs */ )
+const Vector3 gFunction4Output(10.0f, 20.0f, 30.0f);
+void Function4(Vector3& current, const PropertyInputContainer& /* inputs */)
{
// current is output from Function3
- DALI_TEST_EQUALS( current, gFunction3Output, TEST_LOCATION );
+ DALI_TEST_EQUALS(current, gFunction3Output, TEST_LOCATION);
current = gFunction4Output;
}
-void Function5( Vector3& current, const PropertyInputContainer& /* inputs */ )
+void Function5(Vector3& current, const PropertyInputContainer& /* inputs */)
{
// current is output from Function4
- DALI_TEST_EQUALS( current, gFunction4Output, TEST_LOCATION );
+ DALI_TEST_EQUALS(current, gFunction4Output, TEST_LOCATION);
current = Vector3::ZERO;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- Constraint constraint1 = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &TestChaining::Function1 );
- Constraint constraint2 = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &TestChaining::Function2 );
- Constraint constraint3 = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &TestChaining::Function3 );
- Constraint constraint4 = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &TestChaining::Function4 );
- Constraint constraint5 = Constraint::New< Vector3 >( actor, Actor::Property::POSITION, &TestChaining::Function5 );
+ Constraint constraint1 = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &TestChaining::Function1);
+ Constraint constraint2 = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &TestChaining::Function2);
+ Constraint constraint3 = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &TestChaining::Function3);
+ Constraint constraint4 = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &TestChaining::Function4);
+ Constraint constraint5 = Constraint::New<Vector3>(actor, Actor::Property::POSITION, &TestChaining::Function5);
constraint1.Apply();
constraint2.Apply();
///////////////////////////////////////////////////////////////////////////////
namespace TestPropertyTypes
{
-template< typename T >
-void Execute( T value )
+template<typename T>
+void Execute(T value)
{
TestApplication application;
- bool functorCalled = false;
+ bool functorCalled = false;
- Actor actor = Actor::New();
- Property::Index index = actor.RegisterProperty( "TEMP_PROPERTY_NAME", value );
+ Actor actor = Actor::New();
+ Property::Index index = actor.RegisterProperty("TEMP_PROPERTY_NAME", value);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, false, TEST_LOCATION);
// Add a constraint
- Constraint constraint = Constraint::New< T >( actor, index, BasicCalledFunctor< T >( functorCalled ) );
- DALI_TEST_CHECK( constraint );
+ Constraint constraint = Constraint::New<T>(actor, index, BasicCalledFunctor<T>(functorCalled));
+ DALI_TEST_CHECK(constraint);
constraint.Apply();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
}
-} // namespace UtcDaliConstraintNewFunctor
+} // namespace TestPropertyTypes
int UtcDaliConstraintTestPropertyTypesP(void)
{
// Ensure we can use a constraint functor with all supported property types
- TestPropertyTypes::Execute< bool >( false );
- TestPropertyTypes::Execute< int >( 0 );
- TestPropertyTypes::Execute< float >( 0.0f );
- TestPropertyTypes::Execute< Vector2 >( Vector2::ZERO );
- TestPropertyTypes::Execute< Vector3 >( Vector3::ZERO );
- TestPropertyTypes::Execute< Vector4 >( Vector4::ZERO );
- TestPropertyTypes::Execute< Quaternion >( Quaternion::IDENTITY );
- TestPropertyTypes::Execute< Matrix >( Matrix::IDENTITY );
- TestPropertyTypes::Execute< Matrix3 >( Matrix3::IDENTITY );
+ TestPropertyTypes::Execute<bool>(false);
+ TestPropertyTypes::Execute<int>(0);
+ TestPropertyTypes::Execute<float>(0.0f);
+ TestPropertyTypes::Execute<Vector2>(Vector2::ZERO);
+ TestPropertyTypes::Execute<Vector3>(Vector3::ZERO);
+ TestPropertyTypes::Execute<Vector4>(Vector4::ZERO);
+ TestPropertyTypes::Execute<Quaternion>(Quaternion::IDENTITY);
+ TestPropertyTypes::Execute<Matrix>(Matrix::IDENTITY);
+ TestPropertyTypes::Execute<Matrix3>(Matrix3::IDENTITY);
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
namespace
{
-void SetHalfOpacity( Vector4& current, const PropertyInputContainer& inputs )
+void SetHalfOpacity(Vector4& current, const PropertyInputContainer& inputs)
{
current.a = 0.5f;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Check initial value is fully opaque
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
// Create a constraint whose value is discarded when it is removed
- Constraint constraint = Constraint::New< Vector4 >( actor, Actor::Property::COLOR, SetHalfOpacity );
- constraint.SetRemoveAction( Constraint::RemoveAction::DISCARD );
+ Constraint constraint = Constraint::New<Vector4>(actor, Actor::Property::COLOR, SetHalfOpacity);
+ constraint.SetRemoveAction(Constraint::RemoveAction::DISCARD);
constraint.Apply();
// Check value after one render, it should be constrained
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.5f, TEST_LOCATION);
// Render another frame, ensure the other value has also been updated
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.5f, TEST_LOCATION);
// Remove the actor from the stage and delete the constraint
actor.Unparent();
// Check value while off-stage, it should be fully opaque
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
// Add the actor back to the stage and check the value, it should be fully opaque again
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Check value when back on-stage, it should be fully opaque as the constraint is no longer applied to it.
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
// Render for another frame to ensure both buffers have the correct value
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
// Check initial value is fully opaque
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
// Create a constraint whose value is discarded when it is removed
- Constraint constraint = Constraint::New< Vector4 >( actor, Actor::Property::COLOR, SetHalfOpacity );
- constraint.SetRemoveAction( Constraint::RemoveAction::DISCARD );
+ Constraint constraint = Constraint::New<Vector4>(actor, Actor::Property::COLOR, SetHalfOpacity);
+ constraint.SetRemoveAction(Constraint::RemoveAction::DISCARD);
constraint.Apply();
// Check value after one render, it should be constrained
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.5f, TEST_LOCATION);
// Render another frame, ensure the other value has also been updated
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.5f, TEST_LOCATION);
// Remove the actor from the stage
actor.Unparent();
// Check value while off-stage, the constraint is no longer being applied as it's off-stage
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
// Check the other buffer, the constraint should not be applied to this either.
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 1.0f, TEST_LOCATION);
// Add the actor back to the stage and check the value, the constraint should have been re-applied
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.5f, TEST_LOCATION);
// Render for another frame to ensure both buffers have the correct value
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ).a, 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR).a, 0.5f, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintGetTargetObjectNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintSetRemoveActionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintGetTargetPropertyNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintApplyNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintCloneNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintRemoveNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintSetTagNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintGetRemoveActionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
int UtcDaliConstraintGetTagNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Constraint instance;
try
{
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
{
bool gFunctionCalled = false;
-template< typename T >
-void TestCallbackFunction( T& /* current*/ , const PropertyInputContainer& /* inputs */ )
+template<typename T>
+void TestCallbackFunction(T& /* current*/, const PropertyInputContainer& /* inputs */)
{
gFunctionCalled = true;
}
-template< typename T >
+template<typename T>
struct TestCallbackFunctor
{
- TestCallbackFunctor( bool& functorCalled ) : mFunctorCalled( functorCalled ) { }
+ TestCallbackFunctor(bool& functorCalled)
+ : mFunctorCalled(functorCalled)
+ {
+ }
- void operator()( T& /* current*/ , const PropertyInputContainer& /* inputs */ )
+ void operator()(T& /* current*/, const PropertyInputContainer& /* inputs */)
{
mFunctorCalled = true;
}
bool& mFunctorCalled;
};
-template< typename T >
+template<typename T>
struct TestFunctorMethod
{
- TestFunctorMethod( bool& functorCalled ) : mFunctorCalled( functorCalled ) { }
+ TestFunctorMethod(bool& functorCalled)
+ : mFunctorCalled(functorCalled)
+ {
+ }
- void Method( T& /* current*/ , const PropertyInputContainer& /* inputs */ )
+ void Method(T& /* current*/, const PropertyInputContainer& /* inputs */)
{
mFunctorCalled = true;
}
///////////////////////////////////////////////////////////////////////////////
namespace
{
-template< typename T >
+template<typename T>
void TestFunctionConstructor()
{
gFunctionCalled = false;
- Constraint::Function< T > function( &TestCallbackFunction< T > );
- T current;
- PropertyInputContainer inputs;
+ Constraint::Function<T> function(&TestCallbackFunction<T>);
+ T current;
+ PropertyInputContainer inputs;
- DALI_TEST_EQUALS( gFunctionCalled, false, TEST_LOCATION );
- CallbackBase::Execute< T&, const PropertyInputContainer& >( function, current, inputs );
- DALI_TEST_EQUALS( gFunctionCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(gFunctionCalled, false, TEST_LOCATION);
+ CallbackBase::Execute<T&, const PropertyInputContainer&>(function, current, inputs);
+ DALI_TEST_EQUALS(gFunctionCalled, true, TEST_LOCATION);
}
} // unnamed namespace
int UtcDaliConstraintFunctionWithFunction(void)
{
- TestFunctionConstructor< bool >();
- TestFunctionConstructor< int >();
- TestFunctionConstructor< unsigned int >();
- TestFunctionConstructor< float >();
- TestFunctionConstructor< Vector2 >();
- TestFunctionConstructor< Vector3 >();
- TestFunctionConstructor< Vector4 >();
- TestFunctionConstructor< Quaternion >();
- TestFunctionConstructor< Matrix >();
- TestFunctionConstructor< Matrix3 >();
+ TestFunctionConstructor<bool>();
+ TestFunctionConstructor<int>();
+ TestFunctionConstructor<unsigned int>();
+ TestFunctionConstructor<float>();
+ TestFunctionConstructor<Vector2>();
+ TestFunctionConstructor<Vector3>();
+ TestFunctionConstructor<Vector4>();
+ TestFunctionConstructor<Quaternion>();
+ TestFunctionConstructor<Matrix>();
+ TestFunctionConstructor<Matrix3>();
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
namespace
{
-template< typename T >
+template<typename T>
void TestFunctorConstructor()
{
- bool called = false;
- TestCallbackFunctor< T > functor( called );
- Constraint::Function< T > callback( functor );
- T current;
- PropertyInputContainer inputs;
-
- DALI_TEST_EQUALS( called, false, TEST_LOCATION );
- CallbackBase::Execute< T&, const PropertyInputContainer& >( callback, current, inputs );
- DALI_TEST_EQUALS( called, true, TEST_LOCATION );
+ bool called = false;
+ TestCallbackFunctor<T> functor(called);
+ Constraint::Function<T> callback(functor);
+ T current;
+ PropertyInputContainer inputs;
+
+ DALI_TEST_EQUALS(called, false, TEST_LOCATION);
+ CallbackBase::Execute<T&, const PropertyInputContainer&>(callback, current, inputs);
+ DALI_TEST_EQUALS(called, true, TEST_LOCATION);
}
} // unnamed namespace
int UtcDaliConstraintFunctionWithFunctor(void)
{
- TestFunctorConstructor< bool >();
- TestFunctorConstructor< int >();
- TestFunctorConstructor< unsigned int >();
- TestFunctorConstructor< float >();
- TestFunctorConstructor< Vector2 >();
- TestFunctorConstructor< Vector3 >();
- TestFunctorConstructor< Vector4 >();
- TestFunctorConstructor< Quaternion >();
- TestFunctorConstructor< Matrix >();
- TestFunctorConstructor< Matrix3 >();
+ TestFunctorConstructor<bool>();
+ TestFunctorConstructor<int>();
+ TestFunctorConstructor<unsigned int>();
+ TestFunctorConstructor<float>();
+ TestFunctorConstructor<Vector2>();
+ TestFunctorConstructor<Vector3>();
+ TestFunctorConstructor<Vector4>();
+ TestFunctorConstructor<Quaternion>();
+ TestFunctorConstructor<Matrix>();
+ TestFunctorConstructor<Matrix3>();
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
namespace
{
-template< typename T >
+template<typename T>
void TestFunctorMethodConstructor()
{
- bool called = false;
- TestFunctorMethod< T > functor( called );
- Constraint::Function< T > callback( functor, &TestFunctorMethod< T >::Method );
- T current;
- PropertyInputContainer inputs;
-
- DALI_TEST_EQUALS( called, false, TEST_LOCATION );
- CallbackBase::Execute< T&, const PropertyInputContainer& >( callback, current, inputs );
- DALI_TEST_EQUALS( called, true, TEST_LOCATION );
+ bool called = false;
+ TestFunctorMethod<T> functor(called);
+ Constraint::Function<T> callback(functor, &TestFunctorMethod<T>::Method);
+ T current;
+ PropertyInputContainer inputs;
+
+ DALI_TEST_EQUALS(called, false, TEST_LOCATION);
+ CallbackBase::Execute<T&, const PropertyInputContainer&>(callback, current, inputs);
+ DALI_TEST_EQUALS(called, true, TEST_LOCATION);
}
} // unnamed namespace
int UtcDaliConstraintFunctionWithMethodFunctor(void)
{
- TestFunctorMethodConstructor< bool >();
- TestFunctorMethodConstructor< int >();
- TestFunctorMethodConstructor< unsigned int >();
- TestFunctorMethodConstructor< float >();
- TestFunctorMethodConstructor< Vector2 >();
- TestFunctorMethodConstructor< Vector3 >();
- TestFunctorMethodConstructor< Vector4 >();
- TestFunctorMethodConstructor< Quaternion >();
- TestFunctorMethodConstructor< Matrix >();
- TestFunctorMethodConstructor< Matrix3 >();
+ TestFunctorMethodConstructor<bool>();
+ TestFunctorMethodConstructor<int>();
+ TestFunctorMethodConstructor<unsigned int>();
+ TestFunctorMethodConstructor<float>();
+ TestFunctorMethodConstructor<Vector2>();
+ TestFunctorMethodConstructor<Vector3>();
+ TestFunctorMethodConstructor<Vector4>();
+ TestFunctorMethodConstructor<Quaternion>();
+ TestFunctorMethodConstructor<Matrix>();
+ TestFunctorMethodConstructor<Matrix3>();
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
namespace
{
-template< typename T >
+template<typename T>
void TestFunctionClone()
{
gFunctionCalled = false;
- Constraint::Function< T > callback( &TestCallbackFunction< T > );
- CallbackBase* clone = callback.Clone();
+ Constraint::Function<T> callback(&TestCallbackFunction<T>);
+ CallbackBase* clone = callback.Clone();
- T current;
+ T current;
PropertyInputContainer inputs;
- DALI_TEST_EQUALS( gFunctionCalled, false, TEST_LOCATION );
- CallbackBase::Execute< T&, const PropertyInputContainer& >( *clone, current, inputs );
- DALI_TEST_EQUALS( gFunctionCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(gFunctionCalled, false, TEST_LOCATION);
+ CallbackBase::Execute<T&, const PropertyInputContainer&>(*clone, current, inputs);
+ DALI_TEST_EQUALS(gFunctionCalled, true, TEST_LOCATION);
delete clone;
}
-template< typename T >
+template<typename T>
void TestFunctorClone()
{
- bool called = false;
- TestCallbackFunctor< T > functor( called );
- Constraint::Function< T > callback( functor );
- CallbackBase* clone = callback.Clone();
+ bool called = false;
+ TestCallbackFunctor<T> functor(called);
+ Constraint::Function<T> callback(functor);
+ CallbackBase* clone = callback.Clone();
- T current;
+ T current;
PropertyInputContainer inputs;
- DALI_TEST_EQUALS( called, false, TEST_LOCATION );
- CallbackBase::Execute< T&, const PropertyInputContainer& >( *clone, current, inputs );
- DALI_TEST_EQUALS( called, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(called, false, TEST_LOCATION);
+ CallbackBase::Execute<T&, const PropertyInputContainer&>(*clone, current, inputs);
+ DALI_TEST_EQUALS(called, true, TEST_LOCATION);
delete clone;
}
-template< typename T >
+template<typename T>
void TestMethodFunctorClone()
{
- bool called = false;
- TestFunctorMethod< T > functor( called );
- Constraint::Function< T > callback( functor, &TestFunctorMethod< T >::Method );
- CallbackBase* clone = callback.Clone();
+ bool called = false;
+ TestFunctorMethod<T> functor(called);
+ Constraint::Function<T> callback(functor, &TestFunctorMethod<T>::Method);
+ CallbackBase* clone = callback.Clone();
- T current;
+ T current;
PropertyInputContainer inputs;
- DALI_TEST_EQUALS( called, false, TEST_LOCATION );
- CallbackBase::Execute< T&, const PropertyInputContainer& >( *clone, current, inputs );
- DALI_TEST_EQUALS( called, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(called, false, TEST_LOCATION);
+ CallbackBase::Execute<T&, const PropertyInputContainer&>(*clone, current, inputs);
+ DALI_TEST_EQUALS(called, true, TEST_LOCATION);
delete clone;
}
int UtcDaliConstraintFunctionFunctionClone(void)
{
- TestFunctionClone< bool >();
- TestFunctionClone< int >();
- TestFunctionClone< unsigned int >();
- TestFunctionClone< float >();
- TestFunctionClone< Vector2 >();
- TestFunctionClone< Vector3 >();
- TestFunctionClone< Vector4 >();
- TestFunctionClone< Quaternion >();
- TestFunctionClone< Matrix >();
- TestFunctionClone< Matrix3 >();
+ TestFunctionClone<bool>();
+ TestFunctionClone<int>();
+ TestFunctionClone<unsigned int>();
+ TestFunctionClone<float>();
+ TestFunctionClone<Vector2>();
+ TestFunctionClone<Vector3>();
+ TestFunctionClone<Vector4>();
+ TestFunctionClone<Quaternion>();
+ TestFunctionClone<Matrix>();
+ TestFunctionClone<Matrix3>();
END_TEST;
}
int UtcDaliConstraintFunctionFunctorClone(void)
{
- TestFunctorClone< bool >();
- TestFunctorClone< int >();
- TestFunctorClone< unsigned int >();
- TestFunctorClone< float >();
- TestFunctorClone< Vector2 >();
- TestFunctorClone< Vector3 >();
- TestFunctorClone< Vector4 >();
- TestFunctorClone< Quaternion >();
- TestFunctorClone< Matrix >();
- TestFunctorClone< Matrix3 >();
+ TestFunctorClone<bool>();
+ TestFunctorClone<int>();
+ TestFunctorClone<unsigned int>();
+ TestFunctorClone<float>();
+ TestFunctorClone<Vector2>();
+ TestFunctorClone<Vector3>();
+ TestFunctorClone<Vector4>();
+ TestFunctorClone<Quaternion>();
+ TestFunctorClone<Matrix>();
+ TestFunctorClone<Matrix3>();
END_TEST;
}
int UtcDaliConstraintFunctionMethodFunctorClone(void)
{
- TestMethodFunctorClone< bool >();
- TestMethodFunctorClone< int >();
- TestMethodFunctorClone< unsigned int >();
- TestMethodFunctorClone< float >();
- TestMethodFunctorClone< Vector2 >();
- TestMethodFunctorClone< Vector3 >();
- TestMethodFunctorClone< Vector4 >();
- TestMethodFunctorClone< Quaternion >();
- TestMethodFunctorClone< Matrix >();
- TestMethodFunctorClone< Matrix3 >();
+ TestMethodFunctorClone<bool>();
+ TestMethodFunctorClone<int>();
+ TestMethodFunctorClone<unsigned int>();
+ TestMethodFunctorClone<float>();
+ TestMethodFunctorClone<Vector2>();
+ TestMethodFunctorClone<Vector3>();
+ TestMethodFunctorClone<Vector4>();
+ TestMethodFunctorClone<Quaternion>();
+ TestMethodFunctorClone<Matrix>();
+ TestMethodFunctorClone<Matrix3>();
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
{
struct CountFunctor
{
- CountFunctor( int& count )
- : mCount( count )
+ CountFunctor(int& count)
+ : mCount(count)
{
++mCount;
}
- CountFunctor( const CountFunctor& other )
- : mCount( other.mCount )
+ CountFunctor(const CountFunctor& other)
+ : mCount(other.mCount)
{
++mCount;
}
- CountFunctor& operator=( const CountFunctor& other )
+ CountFunctor& operator=(const CountFunctor& other)
{
this->mCount = other.mCount;
++mCount;
--mCount;
}
- void operator()( bool& /* current*/ , const PropertyInputContainer& /* inputs */ )
+ void operator()(bool& /* current*/, const PropertyInputContainer& /* inputs */)
{
}
int count = 0;
{
- CountFunctor functor( count );
- Constraint::Function< bool > callback1( functor );
- Constraint::Function< bool > callback2( functor );
- Constraint::Function< bool > callback3( functor );
- Constraint::Function< bool > callback4( functor );
- Constraint::Function< bool > callback5( functor );
- Constraint::Function< bool > callback6( functor );
- Constraint::Function< bool > callback7( functor );
- Constraint::Function< bool > callback8( functor );
- Constraint::Function< bool > callback9( functor );
- DALI_TEST_EQUALS( count, 10, TEST_LOCATION );
+ CountFunctor functor(count);
+ Constraint::Function<bool> callback1(functor);
+ Constraint::Function<bool> callback2(functor);
+ Constraint::Function<bool> callback3(functor);
+ Constraint::Function<bool> callback4(functor);
+ Constraint::Function<bool> callback5(functor);
+ Constraint::Function<bool> callback6(functor);
+ Constraint::Function<bool> callback7(functor);
+ Constraint::Function<bool> callback8(functor);
+ Constraint::Function<bool> callback9(functor);
+ DALI_TEST_EQUALS(count, 10, TEST_LOCATION);
}
- DALI_TEST_EQUALS( count, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(count, 0, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
int UtcDaliLocalSource(void)
{
- LocalSource source( Actor::Property::POSITION );
+ LocalSource source(Actor::Property::POSITION);
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::POSITION, TEST_LOCATION );
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::POSITION, TEST_LOCATION);
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
int UtcDaliParentSource(void)
{
- ParentSource source( Actor::Property::POSITION );
+ ParentSource source(Actor::Property::POSITION);
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::POSITION, TEST_LOCATION );
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::POSITION, TEST_LOCATION);
END_TEST;
}
///////////////////////////////////////////////////////////////////////////////
int UtcDaliSource1(void)
{
- Actor actor;
- Source source( actor, Actor::Property::SIZE );
+ Actor actor;
+ Source source(actor, Actor::Property::SIZE);
- DALI_TEST_CHECK( ! source.object );
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::SIZE, TEST_LOCATION );
+ DALI_TEST_CHECK(!source.object);
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::SIZE, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Source source( actor, Actor::Property::SIZE );
- DALI_TEST_EQUALS( source.object, actor, TEST_LOCATION );
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::SIZE, TEST_LOCATION );
+ Source source(actor, Actor::Property::SIZE);
+ DALI_TEST_EQUALS(source.object, actor, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::SIZE, TEST_LOCATION);
END_TEST;
}
{
Actor actor;
- ConstraintSource source( Source( actor, Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( ! source.object );
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION );
- DALI_TEST_EQUALS( source.sourceType, OBJECT_PROPERTY, TEST_LOCATION );
+ ConstraintSource source(Source(actor, Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(!source.object);
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.sourceType, OBJECT_PROPERTY, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- ConstraintSource source( Source( actor, Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_EQUALS( source.object, actor, TEST_LOCATION );
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION );
- DALI_TEST_EQUALS( source.sourceType, OBJECT_PROPERTY, TEST_LOCATION );
+ ConstraintSource source(Source(actor, Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_EQUALS(source.object, actor, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.sourceType, OBJECT_PROPERTY, TEST_LOCATION);
END_TEST;
}
{
Actor actor;
- ConstraintSource source( LocalSource( Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( ! source.object );
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION );
- DALI_TEST_EQUALS( source.sourceType, LOCAL_PROPERTY, TEST_LOCATION );
+ ConstraintSource source(LocalSource(Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(!source.object);
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.sourceType, LOCAL_PROPERTY, TEST_LOCATION);
END_TEST;
}
{
Actor actor;
- ConstraintSource source( ParentSource( Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( ! source.object );
- DALI_TEST_EQUALS( source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION );
- DALI_TEST_EQUALS( source.sourceType, PARENT_PROPERTY, TEST_LOCATION );
+ ConstraintSource source(ParentSource(Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(!source.object);
+ DALI_TEST_EQUALS(source.propertyIndex, (Property::Index)Actor::Property::PARENT_ORIGIN, TEST_LOCATION);
+ DALI_TEST_EQUALS(source.sourceType, PARENT_PROPERTY, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
struct PropertyInputImpl : public PropertyInput
{
public:
-
// Constants
- static const bool BOOLEAN_VALUE;
- static const float FLOAT_VALUE;
- static const int INTEGER_VALUE;
- static const Vector2 VECTOR2_VALUE;
- static const Vector3 VECTOR3_VALUE;
- static const Vector4 VECTOR4_VALUE;
- static const Matrix3 MATRIX3_VALUE;
- static const Matrix MATRIX_VALUE;
+ static const bool BOOLEAN_VALUE;
+ static const float FLOAT_VALUE;
+ static const int INTEGER_VALUE;
+ static const Vector2 VECTOR2_VALUE;
+ static const Vector3 VECTOR3_VALUE;
+ static const Vector4 VECTOR4_VALUE;
+ static const Matrix3 MATRIX3_VALUE;
+ static const Matrix MATRIX_VALUE;
static const Quaternion QUATERNION_VALUE;
// Construction & Destruction
- PropertyInputImpl( Property::Type type ) : mType( type ) { }
- virtual ~PropertyInputImpl() { }
+ PropertyInputImpl(Property::Type type)
+ : mType(type)
+ {
+ }
+ virtual ~PropertyInputImpl()
+ {
+ }
// Methods
- Property::Type GetType() const { return mType; }
+ Property::Type GetType() const
+ {
+ return mType;
+ }
// Virtual Methods
- virtual const bool& GetBoolean() const { return BOOLEAN_VALUE; }
- virtual const float& GetFloat() const { return FLOAT_VALUE; }
- virtual const int& GetInteger() const { return INTEGER_VALUE; }
- virtual const Vector2& GetVector2() const { return VECTOR2_VALUE; }
- virtual const Vector3& GetVector3() const { return VECTOR3_VALUE; }
- virtual const Vector4& GetVector4() const { return VECTOR4_VALUE; }
- virtual const Matrix3& GetMatrix3() const { return MATRIX3_VALUE; }
- virtual const Matrix& GetMatrix() const { return MATRIX_VALUE; }
- virtual const Quaternion& GetQuaternion() const { return QUATERNION_VALUE; }
+ virtual const bool& GetBoolean() const
+ {
+ return BOOLEAN_VALUE;
+ }
+ virtual const float& GetFloat() const
+ {
+ return FLOAT_VALUE;
+ }
+ virtual const int& GetInteger() const
+ {
+ return INTEGER_VALUE;
+ }
+ virtual const Vector2& GetVector2() const
+ {
+ return VECTOR2_VALUE;
+ }
+ virtual const Vector3& GetVector3() const
+ {
+ return VECTOR3_VALUE;
+ }
+ virtual const Vector4& GetVector4() const
+ {
+ return VECTOR4_VALUE;
+ }
+ virtual const Matrix3& GetMatrix3() const
+ {
+ return MATRIX3_VALUE;
+ }
+ virtual const Matrix& GetMatrix() const
+ {
+ return MATRIX_VALUE;
+ }
+ virtual const Quaternion& GetQuaternion() const
+ {
+ return QUATERNION_VALUE;
+ }
// Data
Property::Type mType;
};
-const bool PropertyInputImpl::BOOLEAN_VALUE = true;
-const float PropertyInputImpl::FLOAT_VALUE = 123.0f;
-const int PropertyInputImpl::INTEGER_VALUE = 456;
-const Vector2 PropertyInputImpl::VECTOR2_VALUE = Vector2( 10.0f, 20.0f );
-const Vector3 PropertyInputImpl::VECTOR3_VALUE = Vector3( 30.0f, 40.0f, 50.0f );
-const Vector4 PropertyInputImpl::VECTOR4_VALUE = Vector4( 60.0f, 70.0f, 80.0f, 90.0f );
-const Matrix3 PropertyInputImpl::MATRIX3_VALUE ( 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f,
- 7.0f, 8.0f, 9.0f );
-const Matrix PropertyInputImpl::MATRIX_VALUE = Matrix::IDENTITY;
-const Quaternion PropertyInputImpl::QUATERNION_VALUE ( 1.0f, 2.0f, 3.0f, 4.0f );
+const bool PropertyInputImpl::BOOLEAN_VALUE = true;
+const float PropertyInputImpl::FLOAT_VALUE = 123.0f;
+const int PropertyInputImpl::INTEGER_VALUE = 456;
+const Vector2 PropertyInputImpl::VECTOR2_VALUE = Vector2(10.0f, 20.0f);
+const Vector3 PropertyInputImpl::VECTOR3_VALUE = Vector3(30.0f, 40.0f, 50.0f);
+const Vector4 PropertyInputImpl::VECTOR4_VALUE = Vector4(60.0f, 70.0f, 80.0f, 90.0f);
+const Matrix3 PropertyInputImpl::MATRIX3_VALUE(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f);
+const Matrix PropertyInputImpl::MATRIX_VALUE = Matrix::IDENTITY;
+const Quaternion PropertyInputImpl::QUATERNION_VALUE(1.0f, 2.0f, 3.0f, 4.0f);
struct Vector3PropertyInput : public PropertyInputImpl
{
public:
-
// Construction & Destruction
- Vector3PropertyInput( Vector3& value )
- : PropertyInputImpl( Property::VECTOR3 ),
- mValue( value )
+ Vector3PropertyInput(Vector3& value)
+ : PropertyInputImpl(Property::VECTOR3),
+ mValue(value)
{
}
struct QuaternionPropertyInput : public PropertyInputImpl
{
public:
-
// Construction & Destruction
- QuaternionPropertyInput( Quaternion& value )
- : PropertyInputImpl( Property::ROTATION ),
- mValue( value )
+ QuaternionPropertyInput(Quaternion& value)
+ : PropertyInputImpl(Property::ROTATION),
+ mValue(value)
{
}
int UtcDaliConstraintsEqualToConstraintFloat(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::FLOAT );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::FLOAT);
+ inputs.PushBack(&input);
float value = 0.0f;
- DALI_TEST_CHECK( value != PropertyInputImpl::FLOAT_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::FLOAT_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::FLOAT_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::FLOAT_VALUE, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsEqualToConstraintVector2(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::VECTOR2 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::VECTOR2);
+ inputs.PushBack(&input);
Vector2 value;
- DALI_TEST_CHECK( value != PropertyInputImpl::VECTOR2_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::VECTOR2_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::VECTOR2_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::VECTOR2_VALUE, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsEqualToConstraintVector3(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::VECTOR3 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::VECTOR3);
+ inputs.PushBack(&input);
Vector3 value;
- DALI_TEST_CHECK( value != PropertyInputImpl::VECTOR3_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::VECTOR3_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::VECTOR3_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::VECTOR3_VALUE, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsEqualToConstraintVector4(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::VECTOR4 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::VECTOR4);
+ inputs.PushBack(&input);
Vector4 value;
- DALI_TEST_CHECK( value != PropertyInputImpl::VECTOR4_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::VECTOR4_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::VECTOR4_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::VECTOR4_VALUE, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsEqualToConstraintQuaternion(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::ROTATION );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::ROTATION);
+ inputs.PushBack(&input);
Quaternion value;
- DALI_TEST_CHECK( value != PropertyInputImpl::QUATERNION_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::QUATERNION_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::QUATERNION_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::QUATERNION_VALUE, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsEqualToConstraintMatrix3(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::MATRIX3 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::MATRIX3);
+ inputs.PushBack(&input);
Matrix3 value;
- DALI_TEST_CHECK( value != PropertyInputImpl::MATRIX3_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::MATRIX3_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::MATRIX3_VALUE, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(value, PropertyInputImpl::MATRIX3_VALUE, 0.1f, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsEqualToConstraintMatrix(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::MATRIX );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::MATRIX);
+ inputs.PushBack(&input);
Matrix value;
- DALI_TEST_CHECK( value != PropertyInputImpl::MATRIX_VALUE );
+ DALI_TEST_CHECK(value != PropertyInputImpl::MATRIX_VALUE);
EqualToConstraint constraint;
- constraint( value, inputs );
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::MATRIX_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::MATRIX_VALUE, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsRelativeToConstraintUsingFloat(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::VECTOR3 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::VECTOR3);
+ inputs.PushBack(&input);
Vector3 value;
- DALI_TEST_EQUALS( value, Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, Vector3::ZERO, TEST_LOCATION);
- const float scale( 4.0f );
- RelativeToConstraint constraint( scale );
- constraint( value, inputs );
+ const float scale(4.0f);
+ RelativeToConstraint constraint(scale);
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::VECTOR3_VALUE * scale, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::VECTOR3_VALUE * scale, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsRelativeToConstraintUsingVector3(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::VECTOR3 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::VECTOR3);
+ inputs.PushBack(&input);
Vector3 value;
- DALI_TEST_EQUALS( value, Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, Vector3::ZERO, TEST_LOCATION);
- const Vector3 scale( 4.0f, 5.0f, 6.0f );
- RelativeToConstraint constraint( scale );
- constraint( value, inputs );
+ const Vector3 scale(4.0f, 5.0f, 6.0f);
+ RelativeToConstraint constraint(scale);
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::VECTOR3_VALUE * scale, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::VECTOR3_VALUE * scale, TEST_LOCATION);
END_TEST;
}
int UtcDaliConstraintsRelativeToConstraintFloat(void)
{
PropertyInputContainer inputs;
- PropertyInputImpl input( Property::VECTOR3 );
- inputs.PushBack( &input );
+ PropertyInputImpl input(Property::VECTOR3);
+ inputs.PushBack(&input);
- const float scale( 4.0f );
+ const float scale(4.0f);
float value = 0.0f;
- DALI_TEST_CHECK( value != PropertyInputImpl::FLOAT_VALUE * scale );
+ DALI_TEST_CHECK(value != PropertyInputImpl::FLOAT_VALUE * scale);
- RelativeToConstraintFloat constraint( scale );
- constraint( value, inputs );
+ RelativeToConstraintFloat constraint(scale);
+ constraint(value, inputs);
- DALI_TEST_EQUALS( value, PropertyInputImpl::FLOAT_VALUE * scale, TEST_LOCATION );
+ DALI_TEST_EQUALS(value, PropertyInputImpl::FLOAT_VALUE * scale, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION ), Quaternion::IDENTITY, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Quaternion>(Actor::Property::WORLD_ORIENTATION), Quaternion::IDENTITY, TEST_LOCATION);
- Vector3 targetPosition;
- Vector3 cameraPosition;
+ Vector3 targetPosition;
+ Vector3 cameraPosition;
Quaternion targetOrientation;
- Vector3PropertyInput targetPositionProperty( targetPosition );
- Vector3PropertyInput cameraPositionProperty( cameraPosition );
- QuaternionPropertyInput targetOrientationProperty( targetOrientation );
+ Vector3PropertyInput targetPositionProperty(targetPosition);
+ Vector3PropertyInput cameraPositionProperty(cameraPosition);
+ QuaternionPropertyInput targetOrientationProperty(targetOrientation);
PropertyInputContainer inputs;
- inputs.PushBack( &targetPositionProperty );
- inputs.PushBack( &cameraPositionProperty );
- inputs.PushBack( &targetOrientationProperty );
+ inputs.PushBack(&targetPositionProperty);
+ inputs.PushBack(&cameraPositionProperty);
+ inputs.PushBack(&targetOrientationProperty);
Quaternion current;
// 180 degrees round y
- targetPosition = Vector3::ZERO;
- cameraPosition = Vector3( 0.0f, 0.0f, 1.0f );
+ targetPosition = Vector3::ZERO;
+ cameraPosition = Vector3(0.0f, 0.0f, 1.0f);
targetOrientation = Quaternion::IDENTITY;
- Quaternion lookAtOrientation( Quaternion( Radian( Math::PI ), Vector3::YAXIS ) );
- LookAt( current, inputs );
- DALI_TEST_EQUALS( current, lookAtOrientation, TEST_LOCATION );
+ Quaternion lookAtOrientation(Quaternion(Radian(Math::PI), Vector3::YAXIS));
+ LookAt(current, inputs);
+ DALI_TEST_EQUALS(current, lookAtOrientation, TEST_LOCATION);
// 180 degrees round y * -45 degrees round x
- targetPosition = Vector3::ZERO;
- cameraPosition = Vector3( 0.0f, -1.0f, 1.0f );
+ targetPosition = Vector3::ZERO;
+ cameraPosition = Vector3(0.0f, -1.0f, 1.0f);
targetOrientation = Quaternion::IDENTITY;
- lookAtOrientation = Quaternion( Radian( Math::PI ), Vector3::YAXIS ) * Quaternion( Radian( Math::PI * 0.25f ), -Vector3::XAXIS );
- LookAt( current, inputs );
- DALI_TEST_EQUALS( current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION );
+ lookAtOrientation = Quaternion(Radian(Math::PI), Vector3::YAXIS) * Quaternion(Radian(Math::PI * 0.25f), -Vector3::XAXIS);
+ LookAt(current, inputs);
+ DALI_TEST_EQUALS(current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION);
// 180 degrees round y * -45 degrees round x at different points
- targetPosition = Vector3( 0.0f, 1.0f, -1.0f );
- cameraPosition = Vector3::ZERO;
+ targetPosition = Vector3(0.0f, 1.0f, -1.0f);
+ cameraPosition = Vector3::ZERO;
targetOrientation = Quaternion::IDENTITY;
- lookAtOrientation = Quaternion( Radian( Math::PI ), Vector3::YAXIS ) * Quaternion( Radian( Math::PI * 0.25f ), -Vector3::XAXIS );
- LookAt( current, inputs );
- DALI_TEST_EQUALS( current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION );
+ lookAtOrientation = Quaternion(Radian(Math::PI), Vector3::YAXIS) * Quaternion(Radian(Math::PI * 0.25f), -Vector3::XAXIS);
+ LookAt(current, inputs);
+ DALI_TEST_EQUALS(current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION);
// 225 degrees round y
- targetPosition = Vector3( -1.0f, 0.0f, 0.0f );
- cameraPosition = Vector3( 0.0f, 0.0f, 1.0f );
+ targetPosition = Vector3(-1.0f, 0.0f, 0.0f);
+ cameraPosition = Vector3(0.0f, 0.0f, 1.0f);
targetOrientation = Quaternion::IDENTITY;
- lookAtOrientation = Quaternion( Radian( Math::PI * 1.25), Vector3::YAXIS );
- LookAt( current, inputs );
- DALI_TEST_EQUALS( current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION );
+ lookAtOrientation = Quaternion(Radian(Math::PI * 1.25), Vector3::YAXIS);
+ LookAt(current, inputs);
+ DALI_TEST_EQUALS(current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION);
// 180 degrees round y * -45 degrees round x, Up Vector: 180 degrees
- targetPosition = Vector3::ZERO;
- cameraPosition = Vector3( 0.0f, -1.0f, 1.0f );
- targetOrientation = Quaternion( Radian( Math::PI ), Vector3::ZAXIS );
- lookAtOrientation = Quaternion( Radian( Math::PI ), Vector3::YAXIS ) * Quaternion( Radian( Math::PI * 0.25f ), -Vector3::XAXIS ) * Quaternion( Radian( Math::PI ), -Vector3::ZAXIS );
- LookAt( current, inputs );
- DALI_TEST_EQUALS( current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION );
+ targetPosition = Vector3::ZERO;
+ cameraPosition = Vector3(0.0f, -1.0f, 1.0f);
+ targetOrientation = Quaternion(Radian(Math::PI), Vector3::ZAXIS);
+ lookAtOrientation = Quaternion(Radian(Math::PI), Vector3::YAXIS) * Quaternion(Radian(Math::PI * 0.25f), -Vector3::XAXIS) * Quaternion(Radian(Math::PI), -Vector3::ZAXIS);
+ LookAt(current, inputs);
+ DALI_TEST_EQUALS(current, lookAtOrientation, Math::MACHINE_EPSILON_10, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyInputGetExtension(void)
{
- PropertyInputImpl input( Property::BOOLEAN );
- DALI_TEST_CHECK( input.GetExtension() == NULL );
+ PropertyInputImpl input(Property::BOOLEAN);
+ DALI_TEST_CHECK(input.GetExtension() == NULL);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-using namespace Dali;
+#include <iostream>
+using namespace Dali;
namespace
{
static Actor CreateBitmapActor()
{
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::NAME,"Test Image Rendering Actor");
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::NAME, "Test Image Rendering Actor");
return actor;
}
} // anonymous namespace
-
// Positive test case for a method
int UtcDaliContextVertexAttribStartup(void)
{
application.Render();
// check the locations
- for (unsigned int i = 0; i < TEST_MAX_ATTRIBUTE_CACHE_SIZE; i++)
+ for(unsigned int i = 0; i < TEST_MAX_ATTRIBUTE_CACHE_SIZE; i++)
{
- DALI_TEST_CHECK( application.GetGlAbstraction().GetVertexAttribArrayState(i) == false);
+ DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayState(i) == false);
}
tet_result(TET_PASS);
// clear the flag to say they've changed
application.GetGlAbstraction().ClearVertexAttribArrayChanged();
-
// create a test bitmap actor
Actor actor(CreateBitmapActor());
application.GetScene().Add(actor);
-
application.SendNotification();
application.Render();
application.Render();
// if it has changed then the caching has failed
DALI_TEST_CHECK(application.GetGlAbstraction().GetVertexAttribArrayChanged() == false);
-
tet_result(TET_PASS);
END_TEST;
}
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/integration-api/core.h>
+#include <stdlib.h>
+
+#include <cmath> // isfinite
#include <iostream>
#include <sstream>
-#include <cmath> // isfinite
-
-#include <stdlib.h>
-#include <dali/integration-api/core.h>
-#include <dali-test-suite-utils.h>
using namespace Dali;
TestApplication application;
tet_infoline("Testing Dali::GetMaximumUpdateCount");
- DALI_TEST_EQUALS( 2, application.GetCore().GetMaximumUpdateCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(2, application.GetCore().GetMaximumUpdateCount(), TEST_LOCATION);
END_TEST;
}
int UtcDaliCoreGetObjectRegistry(void)
{
TestApplication application;
- DALI_TEST_CHECK( application.GetCore().GetObjectRegistry() );
+ DALI_TEST_CHECK(application.GetCore().GetObjectRegistry());
END_TEST;
}
*
*/
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-
#include <dali/devel-api/actors/custom-actor-devel.h>
-#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/hover-event-integ.h>
-#include <dali/integration-api/events/wheel-event-integ.h>
#include <dali/integration-api/events/key-event-integ.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
+#include <dali/public-api/dali-core.h>
#include <dali/public-api/object/type-registry-helper.h>
+#include <stdlib.h>
+
+#include <iostream>
+
#include "dali-test-suite-utils/dali-test-suite-utils.h"
#include "test-custom-actor.h"
using namespace Dali;
-
void custom_actor_test_startup(void)
{
test_return_value = TET_UNDEF;
test_return_value = TET_PASS;
}
-
-
using namespace Dali;
-
int UtcDaliCustomActorDestructor(void)
{
TestApplication application;
CustomActor* actor = new CustomActor();
delete actor;
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
int UtcDaliCustomActorImplDestructor(void)
{
- TestApplication application;
+ TestApplication application;
CustomActorImpl* actor = new Test::Impl::TestCustomActor();
- CustomActor customActor( *actor ); // Will automatically unref at the end of this function
+ CustomActor customActor(*actor); // Will automatically unref at the end of this function
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
Test::TestCustomActor custom = Test::TestCustomActor::New();
Actor anActor = Actor::New();
- anActor.Add( custom );
+ anActor.Add(custom);
- Actor child = anActor.GetChildAt(0);
- CustomActor customActor = CustomActor::DownCast( child );
- DALI_TEST_CHECK( customActor );
+ Actor child = anActor.GetChildAt(0);
+ CustomActor customActor = CustomActor::DownCast(child);
+ DALI_TEST_CHECK(customActor);
customActor = NULL;
- DALI_TEST_CHECK( !customActor );
+ DALI_TEST_CHECK(!customActor);
- customActor = DownCast< CustomActor >( child );
- DALI_TEST_CHECK( customActor );
+ customActor = DownCast<CustomActor>(child);
+ DALI_TEST_CHECK(customActor);
END_TEST;
}
TestApplication application;
tet_infoline("Testing Dali::CustomActor::DownCast()");
- Actor actor1 = Actor::New();
+ Actor actor1 = Actor::New();
Actor anActor = Actor::New();
anActor.Add(actor1);
- Actor child = anActor.GetChildAt(0);
- CustomActor customActor = CustomActor::DownCast( child );
- DALI_TEST_CHECK( !customActor );
+ Actor child = anActor.GetChildAt(0);
+ CustomActor customActor = CustomActor::DownCast(child);
+ DALI_TEST_CHECK(!customActor);
Actor unInitialzedActor;
- customActor = CustomActor::DownCast( unInitialzedActor );
- DALI_TEST_CHECK( !customActor );
+ customActor = CustomActor::DownCast(unInitialzedActor);
+ DALI_TEST_CHECK(!customActor);
- customActor = DownCast< CustomActor >( unInitialzedActor );
- DALI_TEST_CHECK( !customActor );
+ customActor = DownCast<CustomActor>(unInitialzedActor);
+ DALI_TEST_CHECK(!customActor);
END_TEST;
}
TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_CHECK( custom );
- DALI_TEST_EQUALS( 1, custom.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(custom);
+ DALI_TEST_EQUALS(1, custom.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- int id = custom.GetProperty< int >( Actor::Property::ID );
+ int id = custom.GetProperty<int>(Actor::Property::ID);
- Test::TestCustomActor moved = std::move( custom );
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( id, moved.GetProperty< int >( Actor::Property::ID ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !custom );
+ Test::TestCustomActor moved = std::move(custom);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!custom);
END_TEST;
}
TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_CHECK( custom );
- DALI_TEST_EQUALS( 1, custom.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(custom);
+ DALI_TEST_EQUALS(1, custom.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- int id = custom.GetProperty< int >( Actor::Property::ID );
+ int id = custom.GetProperty<int>(Actor::Property::ID);
Test::TestCustomActor moved;
- moved = std::move( custom );
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( id, moved.GetProperty< int >( Actor::Property::ID ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !custom );
+ moved = std::move(custom);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(id, moved.GetProperty<int>(Actor::Property::ID), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!custom);
END_TEST;
}
tet_infoline("Testing Dali::CustomActor::OnSceneConnection() & OnSceneDisconnection");
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_EQUALS( 0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
// add the custom actor to stage
- application.GetScene().Add( custom );
+ application.GetScene().Add(custom);
- DALI_TEST_EQUALS( 1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", custom.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", custom.GetMethodsCalled()[0], TEST_LOCATION);
- application.GetScene().Remove( custom );
+ application.GetScene().Remove(custom);
- DALI_TEST_EQUALS( 2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", custom.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", custom.GetMethodsCalled()[1], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorA = Test::TestCustomActor::New();
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
Test::TestCustomActor actorC = Test::TestCustomActor::New();
- actorC.SetProperty( Actor::Property::NAME, "ActorC" );
- actorA.Add( actorC );
+ actorC.SetProperty(Actor::Property::NAME, "ActorC");
+ actorA.Add(actorC);
Test::TestCustomActor actorD = Test::TestCustomActor::New();
- actorD.SetProperty( Actor::Property::NAME, "ActorD" );
- actorB.Add( actorD );
+ actorD.SetProperty(Actor::Property::NAME, "ActorD");
+ actorB.Add(actorD);
Test::TestCustomActor actorE = Test::TestCustomActor::New();
- actorE.SetProperty( Actor::Property::NAME, "ActorE" );
- actorB.Add( actorE );
+ actorE.SetProperty(Actor::Property::NAME, "ActorE");
+ actorB.Add(actorE);
Test::TestCustomActor actorF = Test::TestCustomActor::New();
- actorF.SetProperty( Actor::Property::NAME, "ActorF" );
- actorC.Add( actorF );
+ actorF.SetProperty(Actor::Property::NAME, "ActorF");
+ actorC.Add(actorF);
// add the custom actor to stage
- application.GetScene().Add( actorA );
+ application.GetScene().Add(actorA);
- DALI_TEST_EQUALS( 4, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 3 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(4, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[3], TEST_LOCATION);
- DALI_TEST_EQUALS( 4, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorB.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorB.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 3 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(4, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorB.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorB.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorB.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[3], TEST_LOCATION);
- DALI_TEST_EQUALS( 3, (int)(actorC.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorC.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorC.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorC.GetMethodsCalled()[ 2 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(3, (int)(actorC.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorC.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorC.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorC.GetMethodsCalled()[2], TEST_LOCATION);
- DALI_TEST_EQUALS( 2, (int)(actorD.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorD.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorD.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorD.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorD.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorD.GetMethodsCalled()[1], TEST_LOCATION);
- DALI_TEST_EQUALS( 2, (int)(actorE.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorE.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorE.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorE.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorE.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorE.GetMethodsCalled()[1], TEST_LOCATION);
- DALI_TEST_EQUALS( 2, (int)(actorF.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorF.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorF.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorF.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorF.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorF.GetMethodsCalled()[1], TEST_LOCATION);
// Check sequence is correct in MasterCallStack
- DALI_TEST_EQUALS( 4+4+3+2+2+2, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(4 + 4 + 3 + 2 + 2 + 2, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorC: OnPropertySet", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorD: OnPropertySet", MasterCallStack[ 5 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorC: OnPropertySet", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorD: OnPropertySet", MasterCallStack[5], TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorB: OnChildAdd", MasterCallStack[ 6 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorE: OnPropertySet", MasterCallStack[ 7 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnChildAdd", MasterCallStack[ 8 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorF: OnPropertySet", MasterCallStack[ 9 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorC: OnChildAdd", MasterCallStack[ 10 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorB: OnChildAdd", MasterCallStack[6], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorE: OnPropertySet", MasterCallStack[7], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnChildAdd", MasterCallStack[8], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorF: OnPropertySet", MasterCallStack[9], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorC: OnChildAdd", MasterCallStack[10], TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 11 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 12 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorD: OnSceneConnection", MasterCallStack[ 13 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorE: OnSceneConnection", MasterCallStack[ 14 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorC: OnSceneConnection", MasterCallStack[ 15 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorF: OnSceneConnection", MasterCallStack[ 16 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[11], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[12], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorD: OnSceneConnection", MasterCallStack[13], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorE: OnSceneConnection", MasterCallStack[14], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorC: OnSceneConnection", MasterCallStack[15], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorF: OnSceneConnection", MasterCallStack[16], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorA = Test::TestCustomActor::New();
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
- stage.Add( actorA );
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
+ stage.Add(actorA);
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
Test::TestCustomActor actorC = Test::TestCustomActor::New();
- actorC.SetProperty( Actor::Property::NAME, "ActorC" );
- actorA.Add( actorC );
+ actorC.SetProperty(Actor::Property::NAME, "ActorC");
+ actorA.Add(actorC);
Test::TestCustomActor actorD = Test::TestCustomActor::New();
- actorD.SetProperty( Actor::Property::NAME, "ActorD" );
- actorB.Add( actorD );
+ actorD.SetProperty(Actor::Property::NAME, "ActorD");
+ actorB.Add(actorD);
Test::TestCustomActor actorE = Test::TestCustomActor::New();
- actorE.SetProperty( Actor::Property::NAME, "ActorE" );
- actorB.Add( actorE );
+ actorE.SetProperty(Actor::Property::NAME, "ActorE");
+ actorB.Add(actorE);
Test::TestCustomActor actorF = Test::TestCustomActor::New();
- actorF.SetProperty( Actor::Property::NAME, "ActorF" );
- actorC.Add( actorF );
+ actorF.SetProperty(Actor::Property::NAME, "ActorF");
+ actorC.Add(actorF);
// Excercise the message passing to Update thread
actorF.ResetCallStack();
MasterCallStack.clear();
- stage.Remove( actorA );
+ stage.Remove(actorA);
- DALI_TEST_EQUALS( 1, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorA.GetMethodsCalled()[0], TEST_LOCATION);
- DALI_TEST_EQUALS( 1, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorB.GetMethodsCalled()[0], TEST_LOCATION);
- DALI_TEST_EQUALS( 1, (int)(actorC.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorC.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorC.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorC.GetMethodsCalled()[0], TEST_LOCATION);
- DALI_TEST_EQUALS( 1, (int)(actorD.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorD.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorD.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorD.GetMethodsCalled()[0], TEST_LOCATION);
- DALI_TEST_EQUALS( 1, (int)(actorE.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorE.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorE.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorE.GetMethodsCalled()[0], TEST_LOCATION);
- DALI_TEST_EQUALS( 1, (int)(actorF.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorF.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorF.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorF.GetMethodsCalled()[0], TEST_LOCATION);
// Check sequence is correct in MasterCallStack
- DALI_TEST_EQUALS( 6, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(6, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorD: OnSceneDisconnection", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorE: OnSceneDisconnection", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneDisconnection", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorF: OnSceneDisconnection", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorC: OnSceneDisconnection", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneDisconnection", MasterCallStack[ 5 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorD: OnSceneDisconnection", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorE: OnSceneDisconnection", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneDisconnection", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorF: OnSceneDisconnection", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorC: OnSceneDisconnection", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneDisconnection", MasterCallStack[5], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
- Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant1( actorB );
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
- stage.Add( actorA );
+ Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant1(actorB);
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
+ stage.Add(actorA);
// Check callback sequence
- DALI_TEST_EQUALS( 3, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION ); // Called from within OnSceneConnection()
+ DALI_TEST_EQUALS(3, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[2], TEST_LOCATION); // Called from within OnSceneConnection()
- DALI_TEST_EQUALS( 2, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorB.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[1], TEST_LOCATION);
- DALI_TEST_EQUALS( 5, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(5, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 3 ], TEST_LOCATION ); // Occurs during Actor::Add from within from within OnSceneConnection()
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 4 ], TEST_LOCATION ); // Occurs after Actor::Add from within from within OnSceneConnection()
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[3], TEST_LOCATION); // Occurs during Actor::Add from within from within OnSceneConnection()
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[4], TEST_LOCATION); // Occurs after Actor::Add from within from within OnSceneConnection()
// Excercise the message passing to Update thread
// Check everything is ok after Actors are removed
- stage.Remove( actorA );
+ stage.Remove(actorA);
application.SendNotification();
application.Render();
application.Render();
*/
Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant2();
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
Test::TestCustomActor actorC = Test::TestCustomActor::New();
- actorC.SetProperty( Actor::Property::NAME, "ActorC" );
- actorA.Add( actorC );
+ actorC.SetProperty(Actor::Property::NAME, "ActorC");
+ actorA.Add(actorC);
- stage.Add( actorA );
+ stage.Add(actorA);
// Check callback sequence
- DALI_TEST_EQUALS( 6, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildRemove", actorA.GetMethodsCalled()[ 4 ], TEST_LOCATION ); // Called from within OnSceneConnection()
- DALI_TEST_EQUALS( "OnChildRemove", actorA.GetMethodsCalled()[ 5 ], TEST_LOCATION ); // Called from within OnSceneConnection()
-
- DALI_TEST_EQUALS( 8, (int)(MasterCallStack.size()), TEST_LOCATION );
-
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorC: OnPropertySet", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 5 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildRemove", MasterCallStack[ 6 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildRemove", MasterCallStack[ 7 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(6, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildRemove", actorA.GetMethodsCalled()[4], TEST_LOCATION); // Called from within OnSceneConnection()
+ DALI_TEST_EQUALS("OnChildRemove", actorA.GetMethodsCalled()[5], TEST_LOCATION); // Called from within OnSceneConnection()
+
+ DALI_TEST_EQUALS(8, (int)(MasterCallStack.size()), TEST_LOCATION);
+
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorC: OnPropertySet", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[5], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildRemove", MasterCallStack[6], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildRemove", MasterCallStack[7], TEST_LOCATION);
/* Actors B & C should be removed before the point where they could receive an OnSceneConnection callback
* Therefore they shouldn't receive either OnSceneConnection or OnSceneDisconnection
*/
- DALI_TEST_EQUALS( 1, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, (int)(actorC.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, (int)(actorC.GetMethodsCalled().size()), TEST_LOCATION);
// Excercise the message passing to Update thread
// Check everything is ok after last actor is removed
- stage.Remove( actorA );
+ stage.Remove(actorA);
application.SendNotification();
application.Render();
application.Render();
*/
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
- Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant3( actorB );
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
- stage.Add( actorA );
+ Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant3(actorB);
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
+ stage.Add(actorA);
// Excercise the message passing to Update thread
actorB.ResetCallStack();
MasterCallStack.clear();
- stage.Remove( actorA );
+ stage.Remove(actorA);
// Check callback sequence
- DALI_TEST_EQUALS( 2, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[1], TEST_LOCATION);
// Child was added after parent disconnection, so should not receive OnSceneConnection()
- DALI_TEST_EQUALS( 0, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
- DALI_TEST_EQUALS( 2, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorA: OnSceneDisconnection", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorA: OnSceneDisconnection", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[1], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant4();
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
- stage.Add( actorA );
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
+ stage.Add(actorA);
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
// Excercise the message passing to Update thread
actorB.ResetCallStack();
MasterCallStack.clear();
- stage.Remove( actorA );
+ stage.Remove(actorA);
// Check callback sequence
- DALI_TEST_EQUALS( 2, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildRemove", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildRemove", actorA.GetMethodsCalled()[1], TEST_LOCATION);
- DALI_TEST_EQUALS( 1, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorB.GetMethodsCalled()[0], TEST_LOCATION);
- DALI_TEST_EQUALS( 3, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(3, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorB: OnSceneDisconnection", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneDisconnection", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildRemove", MasterCallStack[ 2 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorB: OnSceneDisconnection", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneDisconnection", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildRemove", MasterCallStack[2], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorA = Test::TestCustomActor::New();
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
Test::TestCustomActor actorB = Test::TestCustomActor::NewVariant5(scene);
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
- scene.Add( actorA );
+ scene.Add(actorA);
// Check callback sequence
- DALI_TEST_EQUALS( 4, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorA.GetMethodsCalled()[ 3 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(4, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorA.GetMethodsCalled()[3], TEST_LOCATION);
- DALI_TEST_EQUALS( 2, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorB.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[1], TEST_LOCATION);
- DALI_TEST_EQUALS( 6, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(6, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneDisconnection", MasterCallStack[ 5 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneDisconnection", MasterCallStack[5], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorA = Test::TestCustomActor::New();
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
- scene.Add( actorA );
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
+ scene.Add(actorA);
Test::TestCustomActor actorB = Test::TestCustomActor::NewVariant6(scene);
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
- scene.Remove( actorA );
+ scene.Remove(actorA);
// Check callback sequence
- DALI_TEST_EQUALS( 3, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(3, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[2], TEST_LOCATION);
- DALI_TEST_EQUALS( 3, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorB.GetMethodsCalled()[ 2 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(3, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorB.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorB.GetMethodsCalled()[2], TEST_LOCATION);
// Disconnect was interrupted, so we should only get one OnSceneConnection() for actorB
- DALI_TEST_EQUALS( 6, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(6, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneDisconnection", MasterCallStack[ 5 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneDisconnection", MasterCallStack[5], TEST_LOCATION);
// Excercise the message passing to Update thread
tet_infoline("Testing Dali::CustomActor::OnChildAdd() & OnChildRemove()");
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_EQUALS( 0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
Actor aChild = Actor::New();
- custom.Add( aChild );
+ custom.Add(aChild);
- DALI_TEST_EQUALS( 1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", custom.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", custom.GetMethodsCalled()[0], TEST_LOCATION);
- custom.Remove( aChild );
+ custom.Remove(aChild);
- DALI_TEST_EQUALS( 2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildRemove", custom.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildRemove", custom.GetMethodsCalled()[1], TEST_LOCATION);
END_TEST;
}
* The actorB is the child of actorA
*/
- Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant7( "ActorA" );
- stage.Add( actorA );
+ Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant7("ActorA");
+ stage.Add(actorA);
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ actorA.Add(actorB);
// Check hierarchy is as follows:
// A
// |
// B
- DALI_TEST_EQUALS( 1, (int)(actorA.GetChildCount()), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(actorA.GetChildCount()), TEST_LOCATION);
Actor container = actorA.GetChildAt(0);
Actor containerChild;
- DALI_TEST_CHECK( container );
- if ( container )
+ DALI_TEST_CHECK(container);
+ if(container)
{
- DALI_TEST_EQUALS( "Container", container.GetProperty< std::string >( Actor::Property::NAME ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, (int)(container.GetChildCount()), TEST_LOCATION );
+ DALI_TEST_EQUALS("Container", container.GetProperty<std::string>(Actor::Property::NAME), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, (int)(container.GetChildCount()), TEST_LOCATION);
containerChild = container.GetChildAt(0);
}
- DALI_TEST_CHECK( containerChild );
- if ( containerChild )
+ DALI_TEST_CHECK(containerChild);
+ if(containerChild)
{
- DALI_TEST_EQUALS( "ActorB", containerChild.GetProperty< std::string >( Actor::Property::NAME ), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, (int)(containerChild.GetChildCount()), TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorB", containerChild.GetProperty<std::string>(Actor::Property::NAME), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, (int)(containerChild.GetChildCount()), TEST_LOCATION);
}
// Check callback sequence
- DALI_TEST_EQUALS( 5, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION ); // The mContainer added to actorA
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 3 ], TEST_LOCATION ); // The actorB added to actorA
- DALI_TEST_EQUALS( "OnChildRemove", actorA.GetMethodsCalled()[ 4 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(5, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[1], TEST_LOCATION); // The mContainer added to actorA
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[3], TEST_LOCATION); // The actorB added to actorA
+ DALI_TEST_EQUALS("OnChildRemove", actorA.GetMethodsCalled()[4], TEST_LOCATION);
// mContainer will then receive OnChildAdd
- DALI_TEST_EQUALS( 4, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneDisconnection", actorB.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 3 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(4, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorB.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneDisconnection", actorB.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[3], TEST_LOCATION);
- DALI_TEST_EQUALS( 9, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(9, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 5 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneDisconnection", MasterCallStack[ 6 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildRemove", MasterCallStack[ 7 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 8 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[5], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneDisconnection", MasterCallStack[6], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildRemove", MasterCallStack[7], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[8], TEST_LOCATION);
// Excercise the message passing to Update thread
*/
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorB.SetProperty( Actor::Property::NAME, "ActorB" );
- stage.Add( actorB );
+ actorB.SetProperty(Actor::Property::NAME, "ActorB");
+ stage.Add(actorB);
- Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant8( actorB );
- actorA.SetProperty( Actor::Property::NAME, "ActorA" );
- stage.Add( actorA );
+ Test::TestCustomActor actorA = Test::TestCustomActor::NewVariant8(actorB);
+ actorA.SetProperty(Actor::Property::NAME, "ActorA");
+ stage.Add(actorA);
Actor childActor = Actor::New();
- childActor.SetProperty( Actor::Property::NAME, "Child" );
+ childActor.SetProperty(Actor::Property::NAME, "Child");
// Reparent from actorA to actorB
- actorA.Add( childActor );
- actorB.Add( childActor );
+ actorA.Add(childActor);
+ actorB.Add(childActor);
// Check hierarchy is as follows:
// A B
// |
// Child
- DALI_TEST_EQUALS( 0, (int)(actorA.GetChildCount()), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, (int)(actorB.GetChildCount()), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, (int)(childActor.GetChildCount()), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(actorA.GetChildCount()), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, (int)(actorB.GetChildCount()), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, (int)(childActor.GetChildCount()), TEST_LOCATION);
Actor child = actorB.GetChildAt(0);
- DALI_TEST_CHECK( child );
- if ( child )
+ DALI_TEST_CHECK(child);
+ if(child)
{
- DALI_TEST_EQUALS( "Child", child.GetProperty< std::string >( Actor::Property::NAME ), TEST_LOCATION );
+ DALI_TEST_EQUALS("Child", child.GetProperty<std::string>(Actor::Property::NAME), TEST_LOCATION);
}
// Check callback sequence
- DALI_TEST_EQUALS( 4, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorA.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorA.GetMethodsCalled()[ 1 ], TEST_LOCATION ); // The mContainer added to actorA
- DALI_TEST_EQUALS( "OnChildAdd", actorA.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildRemove", actorA.GetMethodsCalled()[ 3 ], TEST_LOCATION ); // The actorB added to actorA
+ DALI_TEST_EQUALS(4, (int)(actorA.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorA.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorA.GetMethodsCalled()[1], TEST_LOCATION); // The mContainer added to actorA
+ DALI_TEST_EQUALS("OnChildAdd", actorA.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildRemove", actorA.GetMethodsCalled()[3], TEST_LOCATION); // The actorB added to actorA
// mContainer will then receive OnChildAdd
- DALI_TEST_EQUALS( 4, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", actorB.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSceneConnection", actorB.GetMethodsCalled()[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(4, (int)(actorB.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", actorB.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSceneConnection", actorB.GetMethodsCalled()[1], TEST_LOCATION);
// The derived class are always notified, no matter the child is successfully removed or not
- DALI_TEST_EQUALS( "OnChildRemove", actorB.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnChildAdd", actorB.GetMethodsCalled()[ 3 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("OnChildRemove", actorB.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnChildAdd", actorB.GetMethodsCalled()[3], TEST_LOCATION);
- DALI_TEST_EQUALS( 8, (int)(MasterCallStack.size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(8, (int)(MasterCallStack.size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "ActorB: OnPropertySet", MasterCallStack[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnSceneConnection", MasterCallStack[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnPropertySet", MasterCallStack[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnSceneConnection", MasterCallStack[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildAdd", MasterCallStack[ 4 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorA: OnChildRemove", MasterCallStack[ 5 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorB: OnPropertySet", MasterCallStack[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnSceneConnection", MasterCallStack[1], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnPropertySet", MasterCallStack[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnSceneConnection", MasterCallStack[3], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildAdd", MasterCallStack[4], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorA: OnChildRemove", MasterCallStack[5], TEST_LOCATION);
// The derived class are always notified, no matter the child is successfully removed or not
- DALI_TEST_EQUALS( "ActorB: OnChildRemove", MasterCallStack[ 6 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "ActorB: OnChildAdd", MasterCallStack[ 7 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("ActorB: OnChildRemove", MasterCallStack[6], TEST_LOCATION);
+ DALI_TEST_EQUALS("ActorB: OnChildAdd", MasterCallStack[7], TEST_LOCATION);
// Excercise the message passing to Update thread
tet_infoline("Testing Dali::CustomActor::OnPropertySet()");
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_EQUALS( 0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
custom.SetDaliProperty("yes");
- DALI_TEST_EQUALS( 1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", custom.GetMethodsCalled()[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", custom.GetMethodsCalled()[0], TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Dali::CustomActor::OnSizeSet()");
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_EQUALS( 0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
-
- custom.SetProperty( Actor::Property::SIZE, Vector2( 9.0f, 10.0f ) );
- DALI_TEST_EQUALS( 2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSizeSet", custom.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", custom.GetMethodsCalled()[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 9.0f, custom.GetSize().width, TEST_LOCATION );
- DALI_TEST_EQUALS( 10.0f, custom.GetSize().height, TEST_LOCATION );
-
- custom.SetProperty( Actor::Property::SIZE, Vector3( 4.0f, 5.0f, 6.0f ) );
- DALI_TEST_EQUALS( 4, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSizeSet", custom.GetMethodsCalled()[ 2 ], TEST_LOCATION );
- DALI_TEST_EQUALS( "OnPropertySet", custom.GetMethodsCalled()[ 3 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 4.0f, custom.GetSize().width, TEST_LOCATION );
- DALI_TEST_EQUALS( 5.0f, custom.GetSize().height, TEST_LOCATION );
- DALI_TEST_EQUALS( 6.0f, custom.GetSize().depth, TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+
+ custom.SetProperty(Actor::Property::SIZE, Vector2(9.0f, 10.0f));
+ DALI_TEST_EQUALS(2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSizeSet", custom.GetMethodsCalled()[0], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", custom.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(9.0f, custom.GetSize().width, TEST_LOCATION);
+ DALI_TEST_EQUALS(10.0f, custom.GetSize().height, TEST_LOCATION);
+
+ custom.SetProperty(Actor::Property::SIZE, Vector3(4.0f, 5.0f, 6.0f));
+ DALI_TEST_EQUALS(4, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSizeSet", custom.GetMethodsCalled()[2], TEST_LOCATION);
+ DALI_TEST_EQUALS("OnPropertySet", custom.GetMethodsCalled()[3], TEST_LOCATION);
+ DALI_TEST_EQUALS(4.0f, custom.GetSize().width, TEST_LOCATION);
+ DALI_TEST_EQUALS(5.0f, custom.GetSize().height, TEST_LOCATION);
+ DALI_TEST_EQUALS(6.0f, custom.GetSize().depth, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Dali::CustomActor::OnSizeAnimation()");
Test::TestCustomActor custom = Test::TestCustomActor::New();
- DALI_TEST_EQUALS( 0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+
+ application.GetScene().Add(custom);
- Animation anim = Animation::New( 1.0f );
- anim.AnimateTo( Property( custom, Actor::Property::SIZE ), Vector3( 8.0f, 9.0f, 10.0f ) );
+ Animation anim = Animation::New(1.0f);
+ anim.AnimateTo(Property(custom, Actor::Property::SIZE), Vector3(8.0f, 9.0f, 10.0f));
anim.Play();
application.SendNotification();
- application.Render( static_cast<unsigned int>( 1000.0f ) );
+ application.Render(static_cast<unsigned int>(1000.0f));
- DALI_TEST_EQUALS( 1, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- DALI_TEST_EQUALS( "OnSizeAnimation", custom.GetMethodsCalled()[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 8.0f, custom.GetTargetSize().width, TEST_LOCATION );
- DALI_TEST_EQUALS( 9.0f, custom.GetTargetSize().height, TEST_LOCATION );
- DALI_TEST_EQUALS( 10.0f, custom.GetTargetSize().depth, TEST_LOCATION );
+ DALI_TEST_EQUALS(2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
+ DALI_TEST_EQUALS("OnSizeAnimation", custom.GetMethodsCalled()[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(8.0f, custom.GetTargetSize().width, TEST_LOCATION);
+ DALI_TEST_EQUALS(9.0f, custom.GetTargetSize().height, TEST_LOCATION);
+ DALI_TEST_EQUALS(10.0f, custom.GetTargetSize().depth, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Size component animation");
Test::TestCustomActor custom = Test::TestCustomActor::New();
- float intialWidth( 10.0f );
+ float intialWidth(10.0f);
- DALI_TEST_EQUALS( 0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
- custom.SetProperty( Actor::Property::SIZE, Vector2( intialWidth, 10.0f) ); // First method
+ DALI_TEST_EQUALS(0, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
- Animation anim = Animation::New( 1.0f );
+ custom.SetProperty(Actor::Property::SIZE, Vector2(intialWidth, 10.0f)); // First method
+ application.GetScene().Add(custom);
+
+ Animation anim = Animation::New(1.0f);
- DALI_TEST_EQUALS( 2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(3, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
- anim.AnimateTo( Property( custom, Actor::Property::SIZE_WIDTH ), 20.0f );
+ anim.AnimateTo(Property(custom, Actor::Property::SIZE_WIDTH), 20.0f);
- DALI_TEST_EQUALS( 2, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(3, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
- anim.Play(); // Triggers second method ( OnSizeAnimation )
+ anim.Play(); // Triggers second method ( OnSizeAnimation )
application.SendNotification();
- application.Render( static_cast<unsigned int>( 1000.0f ) );
+ application.Render(static_cast<unsigned int>(1000.0f));
- DALI_TEST_EQUALS( 3, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION );
+ DALI_TEST_EQUALS(4, (int)(custom.GetMethodsCalled().size()), TEST_LOCATION);
- DALI_TEST_EQUALS( "OnSizeAnimation", custom.GetMethodsCalled()[ 2 ], TEST_LOCATION );
+ DALI_TEST_EQUALS("OnSizeAnimation", custom.GetMethodsCalled()[3], TEST_LOCATION);
END_TEST;
}
int UtcDaliCustomActorImplOnPropertySet(void)
{
- TestApplication application;
+ TestApplication application;
CustomActorImpl* impl = new Test::Impl::SimpleTestCustomActor();
- CustomActor customActor( *impl ); // Will automatically unref at the end of this function
+ CustomActor customActor(*impl); // Will automatically unref at the end of this function
- impl->OnPropertySet( 0, 0 );
+ impl->OnPropertySet(0, 0);
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::New();
- CustomActorImpl& impl = custom.GetImplementation();
- impl.GetOwner(); // Test
+ CustomActorImpl& impl = custom.GetImplementation();
+ impl.GetOwner(); // Test
const Test::TestCustomActor constCustom = Test::TestCustomActor::New();
- const CustomActorImpl& constImpl = constCustom.GetImplementation();
- constImpl.GetOwner(); // Test
+ const CustomActorImpl& constImpl = constCustom.GetImplementation();
+ constImpl.GetOwner(); // Test
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
DALI_TEST_CHECK(customActorObject.DoAction("invalidCommand", attributes) == false);
// Check that the custom actor is visible
- custom.SetProperty( Actor::Property::VISIBLE,true);
- DALI_TEST_CHECK(custom.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
+ custom.SetProperty(Actor::Property::VISIBLE, true);
+ DALI_TEST_CHECK(custom.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
// Check the custom actor performed an action to hide itself
DALI_TEST_CHECK(customActorObject.DoAction("hide", attributes) == true);
application.Render();
// Check that the custom actor is now invisible
- DALI_TEST_CHECK(custom.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == false);
+ DALI_TEST_CHECK(custom.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == false);
// Check the custom actor performed an action to show itself
DALI_TEST_CHECK(customActorObject.DoAction("show", attributes) == true);
application.Render();
// Check that the custom actor is now visible
- DALI_TEST_CHECK(custom.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) == true);
+ DALI_TEST_CHECK(custom.GetCurrentProperty<bool>(Actor::Property::VISIBLE) == true);
END_TEST;
}
int UtcDaliCustomActorCustomActor(void)
{
Dali::CustomActor customA;
- Dali::CustomActor customB( customA );
+ Dali::CustomActor customB(customA);
- DALI_TEST_CHECK( customA == customB );
+ DALI_TEST_CHECK(customA == customB);
END_TEST;
}
{
TestApplication application;
- DALI_TEST_CHECK( gOnRelayout == false );
+ DALI_TEST_CHECK(gOnRelayout == false);
Test::TestCustomActor custom = Test::TestCustomActor::NewNegoSize();
application.GetScene().Add(custom);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( gOnRelayout == true );
+ DALI_TEST_CHECK(gOnRelayout == true);
gOnRelayout = false;
custom.TestRelayoutRequest();
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( gOnRelayout == true );
+ DALI_TEST_CHECK(gOnRelayout == true);
END_TEST;
}
int UtcDaliCustomActorImplGetHeightForWidthBase(void)
{
- TestApplication application;
+ TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::NewNegoSize();
float width = 300.0f;
application.SendNotification();
application.Render();
- float v = custom.TestGetHeightForWidthBase( width );
+ float v = custom.TestGetHeightForWidthBase(width);
- DALI_TEST_CHECK( v == width );
+ DALI_TEST_CHECK(v == width);
END_TEST;
}
int UtcDaliCustomActorImplGetWidthForHeightBase(void)
{
- TestApplication application;
+ TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::NewNegoSize();
float height = 300.0f;
application.SendNotification();
application.Render();
- float v = custom.TestGetWidthForHeightBase( height );
+ float v = custom.TestGetWidthForHeightBase(height);
- DALI_TEST_CHECK( v == height );
+ DALI_TEST_CHECK(v == height);
END_TEST;
}
int UtcDaliCustomActorImplCalculateChildSizeBase(void)
{
- TestApplication application;
+ TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::NewNegoSize();
Actor child = Actor::New();
child.SetResizePolicy(Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS);
- child.SetProperty( Actor::Property::SIZE, Vector2( 150, 150 ) );
+ child.SetProperty(Actor::Property::SIZE, Vector2(150, 150));
application.SendNotification();
application.Render();
- float v = custom.TestCalculateChildSizeBase( child, Dali::Dimension::ALL_DIMENSIONS );
- DALI_TEST_CHECK( v == 0.0f );
+ float v = custom.TestCalculateChildSizeBase(child, Dali::Dimension::ALL_DIMENSIONS);
+ DALI_TEST_CHECK(v == 0.0f);
END_TEST;
}
int UtcDaliCustomActorImplRelayoutDependentOnChildrenBase(void)
{
- TestApplication application;
+ TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::NewNegoSize();
custom.SetResizePolicy(Dali::ResizePolicy::FIT_TO_CHILDREN, Dali::Dimension::ALL_DIMENSIONS);
- bool v = custom.TestRelayoutDependentOnChildrenBase( Dali::Dimension::ALL_DIMENSIONS );
- DALI_TEST_CHECK( v == true );
+ bool v = custom.TestRelayoutDependentOnChildrenBase(Dali::Dimension::ALL_DIMENSIONS);
+ DALI_TEST_CHECK(v == true);
application.SendNotification();
application.Render();
custom.SetResizePolicy(Dali::ResizePolicy::FIXED, Dali::Dimension::ALL_DIMENSIONS);
- v = custom.TestRelayoutDependentOnChildrenBase( Dali::Dimension::WIDTH );
- DALI_TEST_CHECK( v == false );
+ v = custom.TestRelayoutDependentOnChildrenBase(Dali::Dimension::WIDTH);
+ DALI_TEST_CHECK(v == false);
// why is this here?
application.SendNotification();
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "CustomActor" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("CustomActor");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
std::string name;
name = handle.GetTypeName();
tet_result(TET_FAIL);
}
- catch( DaliException& e )
+ catch(DaliException& e)
{
exception = e.condition;
- DALI_TEST_EQUALS( exception, "handle && \"BaseObject handle is empty\"", TEST_LOCATION );
+ DALI_TEST_EQUALS(exception, "handle && \"BaseObject handle is empty\"", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliCustomActorGetExtensionP(void)
{
TestApplication application;
Test::TestCustomActor custom = Test::TestCustomActor::NewVariant5(application.GetScene());
- DALI_TEST_CHECK( NULL == custom.GetImplementation().GetExtension() );
+ DALI_TEST_CHECK(NULL == custom.GetImplementation().GetExtension());
END_TEST;
}
*/
Test::TestCustomActor actorA = Test::TestCustomActor::New();
- stage.Add( actorA );
+ stage.Add(actorA);
Test::TestCustomActor actorB = Test::TestCustomActor::New();
- actorA.Add( actorB );
+ actorA.Add(actorB);
Test::TestCustomActor actorC = Test::TestCustomActor::New();
- actorA.Add( actorC );
+ actorA.Add(actorC);
Test::TestCustomActor actorD = Test::TestCustomActor::New();
- actorB.Add( actorD );
+ actorB.Add(actorD);
Test::TestCustomActor actorE = Test::TestCustomActor::New();
- actorB.Add( actorE );
+ actorB.Add(actorE);
Test::TestCustomActor actorF = Test::TestCustomActor::New();
- actorC.Add( actorF );
+ actorC.Add(actorF);
// Excercise the message passing to Update thread
application.SendNotification();
application.Render();
application.Render();
- DALI_TEST_EQUALS( 1u, actorA.GetDepth(), TEST_LOCATION );
- DALI_TEST_EQUALS( 2u, actorB.GetDepth(), TEST_LOCATION );
- DALI_TEST_EQUALS( 2u, actorC.GetDepth(), TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, actorD.GetDepth(), TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, actorE.GetDepth(), TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, actorF.GetDepth(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1u, actorA.GetDepth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(2u, actorB.GetDepth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(2u, actorC.GetDepth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, actorD.GetDepth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, actorE.GetDepth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, actorF.GetDepth(), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliCustomActorSetGetProperty(void)
{
TestApplication application; // Need the type registry
Test::TestCustomActor actor = Test::TestCustomActor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- actor.SetProperty( Test::TestCustomActor::Property::TEST_PROPERTY1, 0.5f );
- actor.SetProperty( Test::TestCustomActor::Property::TEST_PROPERTY2, Color::WHITE );
- actor.SetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY3, Color::BLUE );
- actor.SetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY4, 20 );
- actor.SetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY5, 40.0f );
+ actor.SetProperty(Test::TestCustomActor::Property::TEST_PROPERTY1, 0.5f);
+ actor.SetProperty(Test::TestCustomActor::Property::TEST_PROPERTY2, Color::WHITE);
+ actor.SetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY3, Color::BLUE);
+ actor.SetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY4, 20);
+ actor.SetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY5, 40.0f);
- Property::Value value = actor.GetProperty( Test::TestCustomActor::Property::TEST_PROPERTY1 );
- DALI_TEST_EQUALS( value.Get<float>(), 0.5f, 0.001f, TEST_LOCATION );
+ Property::Value value = actor.GetProperty(Test::TestCustomActor::Property::TEST_PROPERTY1);
+ DALI_TEST_EQUALS(value.Get<float>(), 0.5f, 0.001f, TEST_LOCATION);
- value = actor.GetProperty( Test::TestCustomActor::Property::TEST_PROPERTY2 );
- DALI_TEST_EQUALS( value.Get<Vector4>(), Color::WHITE, 0.001f, TEST_LOCATION );
+ value = actor.GetProperty(Test::TestCustomActor::Property::TEST_PROPERTY2);
+ DALI_TEST_EQUALS(value.Get<Vector4>(), Color::WHITE, 0.001f, TEST_LOCATION);
+ value = actor.GetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY3);
+ DALI_TEST_EQUALS(value.Get<Vector4>(), Color::BLUE, 0.001f, TEST_LOCATION);
- value = actor.GetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY3 );
- DALI_TEST_EQUALS( value.Get<Vector4>(), Color::BLUE, 0.001f, TEST_LOCATION );
+ value = actor.GetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY4);
+ DALI_TEST_EQUALS(value.Get<int>(), 20, TEST_LOCATION);
- value = actor.GetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY4 );
- DALI_TEST_EQUALS( value.Get<int>(), 20, TEST_LOCATION );
-
- value = actor.GetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY5 );
- DALI_TEST_EQUALS( value.Get<float>(), 40.0f, 0.001f, TEST_LOCATION );
+ value = actor.GetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY5);
+ DALI_TEST_EQUALS(value.Get<float>(), 40.0f, 0.001f, TEST_LOCATION);
// Get read-only property
- value = actor.GetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY6 );
- DALI_TEST_EQUALS( value.Get<float>(), 10.0f, 0.001f, TEST_LOCATION );
+ value = actor.GetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY6);
+ DALI_TEST_EQUALS(value.Get<float>(), 10.0f, 0.001f, TEST_LOCATION);
// Attempt to set read-only property and then ensure value hasn't changed
- actor.SetProperty( Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY6, 40.0f );
- DALI_TEST_EQUALS( value.Get<float>(), 10.0f, 0.001f, TEST_LOCATION );
+ actor.SetProperty(Test::DevelTestCustomActor::Property::DEVEL_TEST_PROPERTY6, 40.0f);
+ DALI_TEST_EQUALS(value.Get<float>(), 10.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int utcDaliActorGetTypeInfo(void)
{
TestApplication application;
- tet_infoline( "Get the type info of a derived actor" );
+ tet_infoline("Get the type info of a derived actor");
Test::TestCustomActor customActor = Test::TestCustomActor::New();
- Dali::TypeInfo typeInfo = Dali::DevelCustomActor::GetTypeInfo( customActor );
+ Dali::TypeInfo typeInfo = Dali::DevelCustomActor::GetTypeInfo(customActor);
- DALI_TEST_EQUALS( typeInfo.GetName(), std::string("TestCustomActor"), TEST_LOCATION );
+ DALI_TEST_EQUALS(typeInfo.GetName(), std::string("TestCustomActor"), TEST_LOCATION);
END_TEST;
}
*/
struct UnregisteredCustomActor : public Dali::CustomActorImpl
{
- UnregisteredCustomActor() : CustomActorImpl( ACTOR_BEHAVIOUR_DEFAULT )
- { }
+ UnregisteredCustomActor()
+ : CustomActorImpl(ACTOR_BEHAVIOUR_DEFAULT)
+ {
+ }
virtual ~UnregisteredCustomActor()
- { }
- virtual void OnSceneConnection( int32_t depth )
- { }
+ {
+ }
+ virtual void OnSceneConnection(int32_t depth)
+ {
+ }
virtual void OnSceneDisconnection()
- { }
+ {
+ }
virtual void OnChildAdd(Actor& child)
- { }
+ {
+ }
virtual void OnChildRemove(Actor& child)
- { }
- virtual void OnPropertySet( Property::Index index, const Property::Value& propertyValue )
- { }
+ {
+ }
+ virtual void OnPropertySet(Property::Index index, const Property::Value& propertyValue)
+ {
+ }
virtual void OnSizeSet(const Vector3& targetSize)
- { }
+ {
+ }
virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize)
- { }
+ {
+ }
virtual bool OnHoverEvent(const HoverEvent& event)
- { return false; }
+ {
+ return false;
+ }
virtual bool OnWheelEvent(const WheelEvent& event)
- { return false; }
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
- { }
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
- { }
+ {
+ return false;
+ }
+ virtual void OnRelayout(const Vector2& size, RelayoutContainer& container)
+ {
+ }
+ virtual void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
+ {
+ }
virtual Vector3 GetNaturalSize()
- { return Vector3(); }
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
- { return 0.f; }
- virtual float GetHeightForWidth( float width )
- { return 0.f; }
- virtual float GetWidthForHeight( float height )
- { return 0.f; }
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
- { return false; }
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
- { }
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
- { }
+ {
+ return Vector3();
+ }
+ virtual float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension)
+ {
+ return 0.f;
+ }
+ virtual float GetHeightForWidth(float width)
+ {
+ return 0.f;
+ }
+ virtual float GetWidthForHeight(float height)
+ {
+ return 0.f;
+ }
+ virtual bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS)
+ {
+ return false;
+ }
+ virtual void OnCalculateRelayoutSize(Dimension::Type dimension)
+ {
+ }
+ virtual void OnLayoutNegotiated(float size, Dimension::Type dimension)
+ {
+ }
};
-}
+} // namespace Impl
struct UnregisteredCustomActor : public Dali::CustomActor
{
static UnregisteredCustomActor New()
{
Impl::UnregisteredCustomActor* impl = new Impl::UnregisteredCustomActor;
- UnregisteredCustomActor custom( *impl ); // takes ownership
+ UnregisteredCustomActor custom(*impl); // takes ownership
return custom;
}
UnregisteredCustomActor()
- { }
+ {
+ }
~UnregisteredCustomActor()
- { }
- UnregisteredCustomActor( Internal::CustomActor* impl )
- : CustomActor( impl )
- { }
- UnregisteredCustomActor( Impl::UnregisteredCustomActor& impl )
- : CustomActor( impl )
- { }
- static UnregisteredCustomActor DownCast( BaseHandle handle )
+ {
+ }
+ UnregisteredCustomActor(Internal::CustomActor* impl)
+ : CustomActor(impl)
+ {
+ }
+ UnregisteredCustomActor(Impl::UnregisteredCustomActor& impl)
+ : CustomActor(impl)
+ {
+ }
+ static UnregisteredCustomActor DownCast(BaseHandle handle)
{
UnregisteredCustomActor hndl;
- CustomActor custom = Dali::CustomActor::DownCast( handle );
- if( custom )
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
+ if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
- Impl::UnregisteredCustomActor* impl = dynamic_cast<Impl::UnregisteredCustomActor*>( &customImpl );
+ Impl::UnregisteredCustomActor* impl = dynamic_cast<Impl::UnregisteredCustomActor*>(&customImpl);
- if( impl )
+ if(impl)
{
- hndl = UnregisteredCustomActor( customImpl.GetOwner() );
+ hndl = UnregisteredCustomActor(customImpl.GetOwner());
}
}
return hndl;
TestApplication application; // Need the type registry
auto custom = UnregisteredCustomActor::New();
- application.GetScene().Add( custom );
+ application.GetScene().Add(custom);
// should have all actor properties
- DALI_TEST_EQUALS( custom.GetPropertyType( Actor::Property::COLOR ), Property::VECTOR4, TEST_LOCATION );
+ DALI_TEST_EQUALS(custom.GetPropertyType(Actor::Property::COLOR), Property::VECTOR4, TEST_LOCATION);
auto actorHandle = Actor::New();
- DALI_TEST_EQUALS( custom.GetPropertyCount(), actorHandle.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(custom.GetPropertyCount(), actorHandle.GetPropertyCount(), TEST_LOCATION);
- DALI_TEST_EQUALS( custom.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
- custom.SetProperty( Actor::Property::VISIBLE, false );
+ DALI_TEST_EQUALS(custom.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
+ custom.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render(); // IsVisible returns scene value
- DALI_TEST_EQUALS( custom.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(custom.GetCurrentProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
// should have custom actor typename (as it has not registered itself)
- DALI_TEST_EQUALS( "CustomActor", custom.GetTypeName(), TEST_LOCATION );
+ DALI_TEST_EQUALS("CustomActor", custom.GetTypeName(), TEST_LOCATION);
// should have actor actions
- custom.DoAction( "show", Property::Map() );
- DALI_TEST_EQUALS( custom.GetProperty( Actor::Property::VISIBLE ).Get<bool>(), true, TEST_LOCATION );
+ custom.DoAction("show", Property::Map());
+ DALI_TEST_EQUALS(custom.GetProperty(Actor::Property::VISIBLE).Get<bool>(), true, TEST_LOCATION);
Animation animation = Animation::New(0.01f); // very short animation
// should be able to animate actor property
- animation.AnimateTo( Property( custom, Actor::Property::POSITION ), Vector3( 100.0f, 150.0f, 200.0f ) );
+ animation.AnimateTo(Property(custom, Actor::Property::POSITION), Vector3(100.0f, 150.0f, 200.0f));
animation.Play();
application.SendNotification();
application.Render(1000.f);
- DALI_TEST_EQUALS( Vector3( 100.0f, 150.0f, 200.0f ), custom.GetProperty( Actor::Property::POSITION ).Get<Vector3>(), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3( 100.0f, 150.0f, 200.0f ), custom.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(100.0f, 150.0f, 200.0f), custom.GetProperty(Actor::Property::POSITION).Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(100.0f, 150.0f, 200.0f), custom.GetCurrentProperty<Vector3>(Actor::Property::POSITION), TEST_LOCATION);
- Dali::WeakHandle<UnregisteredCustomActor> weakRef( custom );
+ Dali::WeakHandle<UnregisteredCustomActor> weakRef(custom);
// should have actor signals
- custom.ConnectSignal( &application, "offScene",
- [weakRef]()
- {
- DALI_TEST_EQUALS( weakRef.GetHandle().GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ), false, TEST_LOCATION );
- } );
+ custom.ConnectSignal(&application, "offScene", [weakRef]() {
+ DALI_TEST_EQUALS(weakRef.GetHandle().GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE), false, TEST_LOCATION);
+ });
- application.GetScene().Remove( custom );
- application.GetScene().Add( custom );
+ application.GetScene().Remove(custom);
+ application.GetScene().Add(custom);
END_TEST;
}
namespace Impl
{
struct DerivedCustomActor : public UnregisteredCustomActor
-{ };
-}
+{
+};
+} // namespace Impl
struct DerivedCustomActor : public UnregisteredCustomActor
{
static DerivedCustomActor New()
{
Impl::DerivedCustomActor* impl = new Impl::DerivedCustomActor;
- DerivedCustomActor custom( *impl ); // takes ownership
+ DerivedCustomActor custom(*impl); // takes ownership
return custom;
}
DerivedCustomActor()
- { }
+ {
+ }
~DerivedCustomActor()
- { }
- DerivedCustomActor( Internal::CustomActor* impl )
- : UnregisteredCustomActor( impl )
- { }
- DerivedCustomActor( Impl::UnregisteredCustomActor& impl )
- : UnregisteredCustomActor( impl )
- { }
+ {
+ }
+ DerivedCustomActor(Internal::CustomActor* impl)
+ : UnregisteredCustomActor(impl)
+ {
+ }
+ DerivedCustomActor(Impl::UnregisteredCustomActor& impl)
+ : UnregisteredCustomActor(impl)
+ {
+ }
};
// register custom
-DALI_TYPE_REGISTRATION_BEGIN( DerivedCustomActor, UnregisteredCustomActor, nullptr );
+DALI_TYPE_REGISTRATION_BEGIN(DerivedCustomActor, UnregisteredCustomActor, nullptr);
DALI_TYPE_REGISTRATION_END()
int UtcDaliCustomActorPropertyRegistrationDefaultValue(void)
TestApplication application; // Need the type registry
// register our base and add a property with default value for it
- Dali::TypeRegistration typeRegistration( typeid( UnregisteredCustomActor ), typeid( Dali::CustomActor ), nullptr );
+ Dali::TypeRegistration typeRegistration(typeid(UnregisteredCustomActor), typeid(Dali::CustomActor), nullptr);
auto derived = DerivedCustomActor::New();
- application.GetScene().Add( derived );
+ application.GetScene().Add(derived);
// should have all actor properties
- DALI_TEST_EQUALS( derived.GetPropertyType( Actor::Property::WORLD_MATRIX ), Property::MATRIX, TEST_LOCATION );
+ DALI_TEST_EQUALS(derived.GetPropertyType(Actor::Property::WORLD_MATRIX), Property::MATRIX, TEST_LOCATION);
auto actorHandle = Actor::New();
- DALI_TEST_EQUALS( derived.GetPropertyCount(), actorHandle.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(derived.GetPropertyCount(), actorHandle.GetPropertyCount(), TEST_LOCATION);
// add a property in base class
- AnimatablePropertyRegistration( typeRegistration, "Foobar", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, 10.f );
+ AnimatablePropertyRegistration(typeRegistration, "Foobar", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX, 10.f);
// should be one more property now
- DALI_TEST_EQUALS( derived.GetPropertyCount(), actorHandle.GetPropertyCount() + 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(derived.GetPropertyCount(), actorHandle.GetPropertyCount() + 1, TEST_LOCATION);
// check that the default value is set for base class
- DALI_TEST_EQUALS( UnregisteredCustomActor::New().GetProperty(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX).Get<float>(), 10.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(UnregisteredCustomActor::New().GetProperty(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX).Get<float>(), 10.f, TEST_LOCATION);
// check that the default value is set for the derived instance as well
- DALI_TEST_EQUALS( derived.GetProperty(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX).Get<float>(), 10.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(derived.GetProperty(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX).Get<float>(), 10.f, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-
// Positive test case for constructors
int UtcDaliDegreeConstructors01(void)
{
TestApplication application;
// Default constructor, does not initialise the value
- Degree degree0( 0.0f );
+ Degree degree0(0.0f);
// Test assignment operator
degree0 = Degree(180.0f);
- DALI_TEST_EQUALS( degree0.degree, 180.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(degree0.degree, 180.0f, 0.001f, TEST_LOCATION);
// Constructor from float value
- Degree degree1( 180.0f );
- DALI_TEST_EQUALS( degree1.degree, 180.0f, 0.001f, TEST_LOCATION );
+ Degree degree1(180.0f);
+ DALI_TEST_EQUALS(degree1.degree, 180.0f, 0.001f, TEST_LOCATION);
// Constructor from a Radian
- Degree degree2( Radian( Math::PI ) );
- DALI_TEST_EQUALS( degree2.degree, 180.0f, 0.001f, TEST_LOCATION );
+ Degree degree2(Radian(Math::PI));
+ DALI_TEST_EQUALS(degree2.degree, 180.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliDegreeCopyConstructor(void)
{
- Degree degree0( 90.0f );
- Degree degree1( degree0 );
- DALI_TEST_EQUALS( degree1.degree, 90.0f, 0.001f, TEST_LOCATION );
+ Degree degree0(90.0f);
+ Degree degree1(degree0);
+ DALI_TEST_EQUALS(degree1.degree, 90.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliDegreeMoveConstructor(void)
{
- Degree degree0( 90.0f );
- Degree degree1 = std::move( degree0 );
- DALI_TEST_EQUALS( degree1.degree, 90.0f, 0.001f, TEST_LOCATION );
+ Degree degree0(90.0f);
+ Degree degree1 = std::move(degree0);
+ DALI_TEST_EQUALS(degree1.degree, 90.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliDegreeCopyAssignment(void)
{
- Degree degree0( 90.0f );
+ Degree degree0(90.0f);
Degree degree1;
degree1 = degree0;
- DALI_TEST_EQUALS( degree1.degree, 90.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(degree1.degree, 90.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliDegreeMoveAssignment(void)
{
- Degree degree0( 90.0f );
+ Degree degree0(90.0f);
Degree degree1;
- degree1 = std::move( degree0 );
- DALI_TEST_EQUALS( degree1.degree, 90.0f, 0.001f, TEST_LOCATION );
+ degree1 = std::move(degree0);
+ DALI_TEST_EQUALS(degree1.degree, 90.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
TestApplication application;
// Comparison between degrees
- Degree degree0( 90.0f );
- Degree degree1( 90.0f );
- Degree degree2( 180.0f );
+ Degree degree0(90.0f);
+ Degree degree1(90.0f);
+ Degree degree2(180.0f);
- DALI_TEST_CHECK( degree0 == degree1 );
- DALI_TEST_CHECK( degree0 != degree2 );
+ DALI_TEST_CHECK(degree0 == degree1);
+ DALI_TEST_CHECK(degree0 != degree2);
// Comparison between radian to degree
- Degree degree3( 180.0f );
- Degree degree4( 90.0f );
- Radian radian0( Math::PI );
+ Degree degree3(180.0f);
+ Degree degree4(90.0f);
+ Radian radian0(Math::PI);
- DALI_TEST_CHECK( degree3 == Degree(radian0) );
- DALI_TEST_CHECK( degree4 != Degree(radian0) );
+ DALI_TEST_CHECK(degree3 == Degree(radian0));
+ DALI_TEST_CHECK(degree4 != Degree(radian0));
// Comparison with float
- Degree degree5( 90.0f );
+ Degree degree5(90.0f);
- DALI_TEST_CHECK( degree5.degree == 90.0f );
- DALI_TEST_CHECK( degree5.degree != 180.0f );
+ DALI_TEST_CHECK(degree5.degree == 90.0f);
+ DALI_TEST_CHECK(degree5.degree != 180.0f);
END_TEST;
}
*
*/
-#include <iostream>
-#include <algorithm>
-
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/images/distance-field.h>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/images/distance-field.h>
-#include <dali-test-suite-utils.h>
+#include <algorithm>
+#include <iostream>
using std::max;
using namespace Dali;
namespace
{
-
static const float ROTATION_EPSILON = 0.0001f;
static unsigned char sourceImage[] =
-{
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
- 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF
-};
+ {
+ 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
} // anonymous namespace
-
-
int UtcDaliGenerateDistanceField(void)
{
- unsigned char distanceField[4*4];
+ unsigned char distanceField[4 * 4];
GenerateDistanceFieldMap(sourceImage, Size(8.0f, 8.0f), distanceField, Size(4.0f, 4.0f), 0, Size(4.0f, 4.0f));
- if(distanceField[0] <= distanceField[5] &&
- distanceField[5] <= distanceField[10] &&
+ if(distanceField[0] <= distanceField[5] &&
+ distanceField[5] <= distanceField[10] &&
distanceField[10] <= distanceField[15])
{
tet_result(TET_PASS);
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
/// Compare a uint16_t value with an unsigned int
-void DALI_TEST_EQUALS( uint16_t value1, unsigned int value2, const char* location )
+void DALI_TEST_EQUALS(uint16_t value1, unsigned int value2, const char* location)
{
- ::DALI_TEST_EQUALS< uint16_t >( value1, static_cast< uint16_t >( value2 ), location );
+ ::DALI_TEST_EQUALS<uint16_t>(value1, static_cast<uint16_t>(value2), location);
}
} // unnamed namespace
TestApplication application;
Extents extent;
- DALI_TEST_EQUALS( extent.start, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.end, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.top, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.bottom, 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(extent.start, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.end, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.top, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.bottom, 0u, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Extents extent( 10u, 20u, 400u, 200u );
- DALI_TEST_EQUALS( extent.start, 10u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.end, 20u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.top, 400u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.bottom, 200u, TEST_LOCATION );
+ Extents extent(10u, 20u, 400u, 200u);
+ DALI_TEST_EQUALS(extent.start, 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.end, 20u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.top, 400u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.bottom, 200u, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Extents extent( 10u, 20u, 400u, 200u );
+ Extents extent(10u, 20u, 400u, 200u);
Extents e2 = extent;
- DALI_TEST_EQUALS( e2.start, 10u, TEST_LOCATION );
- DALI_TEST_EQUALS( e2.end, 20u, TEST_LOCATION );
- DALI_TEST_EQUALS( e2.top, 400u, TEST_LOCATION );
- DALI_TEST_EQUALS( e2.bottom, 200u, TEST_LOCATION );
+ DALI_TEST_EQUALS(e2.start, 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(e2.end, 20u, TEST_LOCATION);
+ DALI_TEST_EQUALS(e2.top, 400u, TEST_LOCATION);
+ DALI_TEST_EQUALS(e2.bottom, 200u, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Extents extent( 10u, 20u, 400u, 200u );
+ Extents extent(10u, 20u, 400u, 200u);
- Extents extent2( extent );
+ Extents extent2(extent);
- DALI_TEST_EQUALS( extent2.start, 10u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent2.end, 20u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent2.top, 400u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent2.bottom, 200u, TEST_LOCATION );
+ DALI_TEST_EQUALS(extent2.start, 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent2.end, 20u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent2.top, 400u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent2.bottom, 200u, TEST_LOCATION);
END_TEST;
}
Extents extent;
- Extents extent2( 10u, 20u, 400u, 200u );
+ Extents extent2(10u, 20u, 400u, 200u);
extent = extent2;
- DALI_TEST_EQUALS( extent.start, 10u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.end, 20u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.top, 400u, TEST_LOCATION );
- DALI_TEST_EQUALS( extent.bottom, 200u, TEST_LOCATION );
+ DALI_TEST_EQUALS(extent.start, 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.end, 20u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.top, 400u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.bottom, 200u, TEST_LOCATION);
END_TEST;
}
int UtcDaliExtentsAssignP(void)
{
- Extents extent;
- const uint16_t array[] = { 1u, 2u, 3u, 4u };
- extent = (const uint16_t*)array;
-
- DALI_TEST_EQUALS( extent.start, 1u, TEST_LOCATION);
- DALI_TEST_EQUALS( extent.end, 2u, TEST_LOCATION);
- DALI_TEST_EQUALS( extent.top, 3u, TEST_LOCATION);
- DALI_TEST_EQUALS( extent.bottom, 4u, TEST_LOCATION);
+ Extents extent;
+ const uint16_t array[] = {1u, 2u, 3u, 4u};
+ extent = (const uint16_t*)array;
+
+ DALI_TEST_EQUALS(extent.start, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.end, 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.top, 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(extent.bottom, 4u, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Extents extent1( 10u, 20u, 200u, 200u );
- Extents extent2( 10u, 120u, 200u, 200u );
- Extents extent3( 10u, 80u, 200u, 200u );
+ Extents extent1(10u, 20u, 200u, 200u);
+ Extents extent2(10u, 120u, 200u, 200u);
+ Extents extent3(10u, 80u, 200u, 200u);
- DALI_TEST_CHECK( extent1 != extent2 );
- DALI_TEST_CHECK( extent1 != extent3 );
+ DALI_TEST_CHECK(extent1 != extent2);
+ DALI_TEST_CHECK(extent1 != extent3);
END_TEST;
}
{
TestApplication application;
- Extents extent1( 10u, 20u, 200u, 200u );
- Extents extent1p( 10u, 20u, 200u, 200u );
+ Extents extent1(10u, 20u, 200u, 200u);
+ Extents extent1p(10u, 20u, 200u, 200u);
- Extents extent2( 10u, 120u, 200u, 200u );
- Extents extent3( 10u, 80u, 200u, 200u );
+ Extents extent2(10u, 120u, 200u, 200u);
+ Extents extent3(10u, 80u, 200u, 200u);
- DALI_TEST_CHECK( extent1 == extent1p );
- DALI_TEST_CHECK( extent1 == extent1 );
- DALI_TEST_CHECK( !( extent1 == extent2 ) );
- DALI_TEST_CHECK( !( extent1 == extent3 ) );
+ DALI_TEST_CHECK(extent1 == extent1p);
+ DALI_TEST_CHECK(extent1 == extent1);
+ DALI_TEST_CHECK(!(extent1 == extent2));
+ DALI_TEST_CHECK(!(extent1 == extent3));
END_TEST;
}
int UtcDaliExtentsOStreamOperatorP(void)
{
- TestApplication application;
+ TestApplication application;
std::ostringstream oss;
- Extents extent( 1u, 2u, 10u, 10u );
+ Extents extent(1u, 2u, 10u, 10u);
oss << extent;
std::string expectedOutput = "[1, 2, 10, 10]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/rendering/frame-buffer-devel.h>
+#include <dali/public-api/dali-core.h>
using namespace Dali;
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
- DALI_TEST_CHECK( frameBuffer );
+ DALI_TEST_CHECK(frameBuffer);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH);
- DALI_TEST_CHECK( frameBuffer );
+ DALI_TEST_CHECK(frameBuffer);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::STENCIL );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::STENCIL);
- DALI_TEST_CHECK( frameBuffer );
+ DALI_TEST_CHECK(frameBuffer);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH_STENCIL );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
- DALI_TEST_CHECK( frameBuffer );
+ DALI_TEST_CHECK(frameBuffer);
application.SendNotification();
application.Render();
int UtcDaliFrameBufferNew05(void)
{
TestApplication application;
- FrameBuffer frameBuffer;
- DALI_TEST_CHECK( !frameBuffer );
+ FrameBuffer frameBuffer;
+ DALI_TEST_CHECK(!frameBuffer);
END_TEST;
}
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, static_cast<FrameBuffer::Attachment::Mask>( FrameBuffer::Attachment::DEPTH | FrameBuffer::Attachment::STENCIL ) );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, static_cast<FrameBuffer::Attachment::Mask>(FrameBuffer::Attachment::DEPTH | FrameBuffer::Attachment::STENCIL));
- DALI_TEST_CHECK( frameBuffer );
+ DALI_TEST_CHECK(frameBuffer);
application.SendNotification();
application.Render();
int UtcDaliFrameBufferNewWithColor01(void)
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height);
application.SendNotification();
application.Render();
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferColorAttachmentCount(), 1u, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferDepthAttachment(), (GLenum)GL_FALSE, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferStencilAttachment(), (GLenum)GL_FALSE, TEST_LOCATION);
// check that texture is not empty handle
- DALI_TEST_CHECK( frameBuffer.GetColorTexture() );
+ DALI_TEST_CHECK(frameBuffer.GetColorTexture());
END_TEST;
}
int UtcDaliFrameBufferNewWithColor02(void)
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::COLOR );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::COLOR);
application.SendNotification();
application.Render();
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferColorAttachmentCount(), 1u, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferDepthAttachment(), (GLenum)GL_FALSE, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferStencilAttachment(), (GLenum)GL_FALSE, TEST_LOCATION);
// check that texture is not empty handle
- DALI_TEST_CHECK( frameBuffer.GetColorTexture() );
+ DALI_TEST_CHECK(frameBuffer.GetColorTexture());
END_TEST;
}
int UtcDaliFrameBufferNewWithColor03(void)
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::COLOR_DEPTH );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::COLOR_DEPTH);
application.SendNotification();
application.Render();
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferColorAttachmentCount(), 1u, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferDepthAttachment(), (GLenum)GL_TRUE, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferStencilAttachment(), (GLenum)GL_FALSE, TEST_LOCATION);
// check that texture is not empty handle
- DALI_TEST_CHECK( frameBuffer.GetColorTexture() );
+ DALI_TEST_CHECK(frameBuffer.GetColorTexture());
END_TEST;
}
int UtcDaliFrameBufferNewWithColor04(void)
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::COLOR_STENCIL );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::COLOR_STENCIL);
application.SendNotification();
application.Render();
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferColorAttachmentCount(), 1u, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferDepthAttachment(), (GLenum)GL_FALSE, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferStencilAttachment(), (GLenum)GL_TRUE, TEST_LOCATION);
// check that texture is not empty handle
- DALI_TEST_CHECK( frameBuffer.GetColorTexture() );
+ DALI_TEST_CHECK(frameBuffer.GetColorTexture());
END_TEST;
}
int UtcDaliFrameBufferNewWithColor05(void)
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::COLOR_DEPTH_STENCIL );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::COLOR_DEPTH_STENCIL);
application.SendNotification();
application.Render();
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferColorAttachmentCount(), 1u, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferDepthAttachment(), (GLenum)GL_TRUE, TEST_LOCATION);
DALI_TEST_EQUALS(application.GetGlAbstraction().CheckFramebufferStencilAttachment(), (GLenum)GL_TRUE, TEST_LOCATION);
// check that texture is not empty handle
- DALI_TEST_CHECK( frameBuffer.GetColorTexture() );
+ DALI_TEST_CHECK(frameBuffer.GetColorTexture());
END_TEST;
}
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
- FrameBuffer frameBufferCopy( frameBuffer );
+ FrameBuffer frameBufferCopy(frameBuffer);
- DALI_TEST_CHECK( frameBufferCopy );
+ DALI_TEST_CHECK(frameBufferCopy);
END_TEST;
}
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
FrameBuffer frameBuffer2;
- DALI_TEST_CHECK( !frameBuffer2 );
+ DALI_TEST_CHECK(!frameBuffer2);
frameBuffer2 = frameBuffer;
- DALI_TEST_CHECK( frameBuffer2 );
+ DALI_TEST_CHECK(frameBuffer2);
END_TEST;
}
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH_STENCIL );
- DALI_TEST_CHECK( frameBuffer );
- DALI_TEST_EQUALS( 1, frameBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
+ DALI_TEST_CHECK(frameBuffer);
+ DALI_TEST_EQUALS(1, frameBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
- DALI_TEST_EQUALS( frameBuffer.GetColorTexture(), texture, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
+ DALI_TEST_EQUALS(frameBuffer.GetColorTexture(), texture, TEST_LOCATION);
- FrameBuffer move = std::move( frameBuffer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetColorTexture(), texture, TEST_LOCATION );
- DALI_TEST_CHECK( !frameBuffer );
+ FrameBuffer move = std::move(frameBuffer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetColorTexture(), texture, TEST_LOCATION);
+ DALI_TEST_CHECK(!frameBuffer);
END_TEST;
}
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH_STENCIL );
- DALI_TEST_CHECK( frameBuffer );
- DALI_TEST_EQUALS( 1, frameBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
+ DALI_TEST_CHECK(frameBuffer);
+ DALI_TEST_EQUALS(1, frameBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
- DALI_TEST_EQUALS( frameBuffer.GetColorTexture(), texture, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
+ DALI_TEST_EQUALS(frameBuffer.GetColorTexture(), texture, TEST_LOCATION);
FrameBuffer move;
- move = std::move( frameBuffer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetColorTexture(), texture, TEST_LOCATION );
- DALI_TEST_CHECK( !frameBuffer );
+ move = std::move(frameBuffer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetColorTexture(), texture, TEST_LOCATION);
+ DALI_TEST_CHECK(!frameBuffer);
END_TEST;
}
int UtcDaliFrameBufferDownCast01(void)
{
TestApplication application;
- unsigned int width(64);
- unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
+ unsigned int width(64);
+ unsigned int height(64);
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
- BaseHandle handle(frameBuffer);
+ BaseHandle handle(frameBuffer);
FrameBuffer frameBuffer2 = FrameBuffer::DownCast(handle);
- DALI_TEST_CHECK( frameBuffer2 );
+ DALI_TEST_CHECK(frameBuffer2);
END_TEST;
}
{
TestApplication application;
- Handle handle = Handle::New(); // Create a custom object
+ Handle handle = Handle::New(); // Create a custom object
FrameBuffer frameBuffer = FrameBuffer::DownCast(handle);
- DALI_TEST_CHECK( !frameBuffer );
+ DALI_TEST_CHECK(!frameBuffer);
END_TEST;
}
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH_STENCIL );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
texture.GenerateMipmaps();
//Attach mipmap 1
- frameBuffer.AttachColorTexture( texture, 0u, 1u );
+ frameBuffer.AttachColorTexture(texture, 0u, 1u);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
texture.GenerateMipmaps();
//Attach NEGATIVE_Y face of the cubemap
- frameBuffer.AttachColorTexture( texture, 0u, CubeMapLayer::NEGATIVE_Y );
+ frameBuffer.AttachColorTexture(texture, 0u, CubeMapLayer::NEGATIVE_Y);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, static_cast<FrameBuffer::Attachment::Mask>( FrameBuffer::Attachment::DEPTH | FrameBuffer::Attachment::STENCIL ) );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, static_cast<FrameBuffer::Attachment::Mask>(FrameBuffer::Attachment::DEPTH | FrameBuffer::Attachment::STENCIL));
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
// N.B. it doesn't make sense per se, however the OGL standard doesn't seem to forbid attaching the same texture to different slots.
- for (int i = 0; i < Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS + 1; ++i)
+ for(int i = 0; i < Dali::DevelFrameBuffer::MAX_COLOR_ATTACHMENTS + 1; ++i)
{
- frameBuffer.AttachColorTexture( texture );
+ frameBuffer.AttachColorTexture(texture);
}
application.SendNotification();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH_STENCIL );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
- Texture textureDepth = Texture::New( TextureType::TEXTURE_2D, Pixel::DEPTH_UNSIGNED_INT, width, height );
- DevelFrameBuffer::AttachDepthTexture( frameBuffer, textureDepth );
+ Texture textureDepth = Texture::New(TextureType::TEXTURE_2D, Pixel::DEPTH_UNSIGNED_INT, width, height);
+ DevelFrameBuffer::AttachDepthTexture(frameBuffer, textureDepth);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::DEPTH_STENCIL );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::DEPTH_STENCIL);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
- Texture textureStencil = Texture::New( TextureType::TEXTURE_2D, Pixel::DEPTH_STENCIL, width, height );
- DevelFrameBuffer::AttachDepthStencilTexture( frameBuffer, textureStencil );
+ Texture textureStencil = Texture::New(TextureType::TEXTURE_2D, Pixel::DEPTH_STENCIL, width, height);
+ DevelFrameBuffer::AttachDepthStencilTexture(frameBuffer, textureStencil);
application.SendNotification();
application.Render();
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
DALI_TEST_EQUALS(frameBuffer.GetColorTexture(), texture, TEST_LOCATION);
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture, 0u, 1u );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture, 0u, 1u);
DALI_TEST_EQUALS(frameBuffer.GetColorTexture(), texture, TEST_LOCATION);
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture, 0u, 1u );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture, 0u, 1u);
DALI_TEST_EQUALS(frameBuffer.GetColorTexture(), texture, TEST_LOCATION);
DALI_TEST_EQUALS(DevelFrameBuffer::GetColorTexture(frameBuffer, 0), texture, TEST_LOCATION);
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture textures[] = {
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
- Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height ),
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture textures[] = {
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
+ Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height),
};
- for (auto& t: textures)
+ for(auto& t : textures)
{
- frameBuffer.AttachColorTexture( t, 0u, 1u );
+ frameBuffer.AttachColorTexture(t, 0u, 1u);
}
- for (unsigned int i = 0; i < std::extent<decltype(textures)>::value; ++i)
+ for(unsigned int i = 0; i < std::extent<decltype(textures)>::value; ++i)
{
DALI_TEST_EQUALS(DevelFrameBuffer::GetColorTexture(frameBuffer, i), textures[i], TEST_LOCATION);
}
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
- Texture textureDepth = Texture::New( TextureType::TEXTURE_2D, Pixel::DEPTH_FLOAT, width, height );
- DevelFrameBuffer::AttachDepthTexture( frameBuffer, textureDepth );
+ Texture textureDepth = Texture::New(TextureType::TEXTURE_2D, Pixel::DEPTH_FLOAT, width, height);
+ DevelFrameBuffer::AttachDepthTexture(frameBuffer, textureDepth);
- DALI_TEST_EQUALS(DevelFrameBuffer::GetDepthTexture( frameBuffer ), textureDepth, TEST_LOCATION);
+ DALI_TEST_EQUALS(DevelFrameBuffer::GetDepthTexture(frameBuffer), textureDepth, TEST_LOCATION);
END_TEST;
}
unsigned int width(64);
unsigned int height(64);
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- frameBuffer.AttachColorTexture( texture );
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ frameBuffer.AttachColorTexture(texture);
- Texture textureStencil = Texture::New( TextureType::TEXTURE_2D, Pixel::DEPTH_STENCIL, width, height );
- DevelFrameBuffer::AttachDepthStencilTexture( frameBuffer, textureStencil );
+ Texture textureStencil = Texture::New(TextureType::TEXTURE_2D, Pixel::DEPTH_STENCIL, width, height);
+ DevelFrameBuffer::AttachDepthStencilTexture(frameBuffer, textureStencil);
- DALI_TEST_EQUALS(DevelFrameBuffer::GetDepthStencilTexture( frameBuffer ), textureStencil, TEST_LOCATION);
+ DALI_TEST_EQUALS(DevelFrameBuffer::GetDepthStencilTexture(frameBuffer), textureStencil, TEST_LOCATION);
END_TEST;
}
//Create the texture
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- DALI_TEST_CHECK( texture );
- FrameBuffer frameBuffer = FrameBuffer::New( width, height, FrameBuffer::Attachment::NONE );
- DALI_TEST_CHECK( frameBuffer );
- frameBuffer.AttachColorTexture( texture, 0u, 1u );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ DALI_TEST_CHECK(texture);
+ FrameBuffer frameBuffer = FrameBuffer::New(width, height, FrameBuffer::Attachment::NONE);
+ DALI_TEST_CHECK(frameBuffer);
+ frameBuffer.AttachColorTexture(texture, 0u, 1u);
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
application.SendNotification();
// Lose & regain context (in render 'thread')
application.ResetContext();
- DALI_TEST_CHECK( frameBuffer );
+ DALI_TEST_CHECK(frameBuffer);
END_TEST;
}
int UtcDaliFrameBufferGetColorTextureNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::FrameBuffer instance;
try
{
int UtcDaliFrameBufferAttachColorTextureNegative01(void)
{
- TestApplication application;
+ TestApplication application;
Dali::FrameBuffer instance;
try
{
int UtcDaliFrameBufferAttachColorTextureNegative02(void)
{
- TestApplication application;
+ TestApplication application;
Dali::FrameBuffer instance;
try
{
Dali::Texture arg1 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 400u, 400u);
- unsigned int arg2(0u);
- unsigned int arg3(0u);
- instance.AttachColorTexture(arg1,arg2,arg3);
+ unsigned int arg2(0u);
+ unsigned int arg3(0u);
+ instance.AttachColorTexture(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/devel-api/common/map-wrapper.h>
#include <dali/devel-api/common/stage-devel.h>
#include <dali/devel-api/update/frame-callback-interface.h>
#include <dali/devel-api/update/update-proxy.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
class FrameCallbackBasic : public FrameCallbackInterface
{
public:
-
FrameCallbackBasic() = default;
- virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds )
+ virtual void Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds)
{
mCalled = true;
}
mCalled = false;
}
- bool mCalled{ false };
+ bool mCalled{false};
};
class FrameCallbackOneActor : public FrameCallbackBasic
{
public:
-
- FrameCallbackOneActor( unsigned int actorId )
- : mActorId( actorId )
+ FrameCallbackOneActor(unsigned int actorId)
+ : mActorId(actorId)
{
}
- virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
+ virtual void Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
{
- FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
- updateProxy.GetSize( mActorId, mSizeGetSizeCall );
- updateProxy.GetPosition( mActorId, mPositionGetPositionCall );
- updateProxy.GetPositionAndSize( mActorId, mPositionGetPositionAndSizeCall, mSizeGetPositionAndSizeCall );
- updateProxy.GetColor( mActorId, mColor );
- updateProxy.GetScale( mActorId, mScale );
+ FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
+ updateProxy.GetSize(mActorId, mSizeGetSizeCall);
+ updateProxy.GetPosition(mActorId, mPositionGetPositionCall);
+ updateProxy.GetPositionAndSize(mActorId, mPositionGetPositionAndSizeCall, mSizeGetPositionAndSizeCall);
+ updateProxy.GetColor(mActorId, mColor);
+ updateProxy.GetScale(mActorId, mScale);
}
const unsigned int mActorId;
class FrameCallbackSetter : public FrameCallbackBasic
{
public:
-
FrameCallbackSetter(
- unsigned int actorId,
- const Vector3& sizeToSet,
- const Vector3& positionToSet,
- const Vector4& colorToSet,
- const Vector3& scaleToSet )
- : mActorId( actorId ),
- mSizeToSet( sizeToSet ),
- mPositionToSet( positionToSet ),
- mColorToSet( colorToSet ),
- mScaleToSet( scaleToSet )
+ unsigned int actorId,
+ const Vector3& sizeToSet,
+ const Vector3& positionToSet,
+ const Vector4& colorToSet,
+ const Vector3& scaleToSet)
+ : mActorId(actorId),
+ mSizeToSet(sizeToSet),
+ mPositionToSet(positionToSet),
+ mColorToSet(colorToSet),
+ mScaleToSet(scaleToSet)
{
}
- virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
+ virtual void Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
{
- FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
- updateProxy.SetSize( mActorId, mSizeToSet );
- updateProxy.SetPosition( mActorId, mPositionToSet );
- updateProxy.SetColor( mActorId, mColorToSet );
- updateProxy.SetScale( mActorId, mScaleToSet );
- updateProxy.GetSize( mActorId, mSizeAfterSetting );
- updateProxy.GetPosition( mActorId, mPositionAfterSetting );
- updateProxy.GetColor( mActorId, mColorAfterSetting );
- updateProxy.GetScale( mActorId, mScaleAfterSetting );
+ FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
+ updateProxy.SetSize(mActorId, mSizeToSet);
+ updateProxy.SetPosition(mActorId, mPositionToSet);
+ updateProxy.SetColor(mActorId, mColorToSet);
+ updateProxy.SetScale(mActorId, mScaleToSet);
+ updateProxy.GetSize(mActorId, mSizeAfterSetting);
+ updateProxy.GetPosition(mActorId, mPositionAfterSetting);
+ updateProxy.GetColor(mActorId, mColorAfterSetting);
+ updateProxy.GetScale(mActorId, mScaleAfterSetting);
}
const unsigned int mActorId;
- const Vector3& mSizeToSet;
- const Vector3& mPositionToSet;
- const Vector4& mColorToSet;
- const Vector3& mScaleToSet;
+ const Vector3& mSizeToSet;
+ const Vector3& mPositionToSet;
+ const Vector4& mColorToSet;
+ const Vector3& mScaleToSet;
Vector3 mSizeAfterSetting;
Vector3 mPositionAfterSetting;
class FrameCallbackBaker : public FrameCallbackBasic
{
public:
-
FrameCallbackBaker(
- unsigned int actorId,
- const Vector3& sizeToSet,
- const Vector3& positionToSet,
- const Vector4& colorToSet,
- const Vector3& scaleToSet )
- : mActorId( actorId ),
- mSizeToSet( sizeToSet ),
- mPositionToSet( positionToSet ),
- mColorToSet( colorToSet ),
- mScaleToSet( scaleToSet )
+ unsigned int actorId,
+ const Vector3& sizeToSet,
+ const Vector3& positionToSet,
+ const Vector4& colorToSet,
+ const Vector3& scaleToSet)
+ : mActorId(actorId),
+ mSizeToSet(sizeToSet),
+ mPositionToSet(positionToSet),
+ mColorToSet(colorToSet),
+ mScaleToSet(scaleToSet)
{
}
- virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
+ virtual void Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
{
- FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
- updateProxy.BakeSize( mActorId, mSizeToSet );
- updateProxy.BakePosition( mActorId, mPositionToSet );
- updateProxy.BakeColor( mActorId, mColorToSet );
- updateProxy.BakeScale( mActorId, mScaleToSet );
- updateProxy.GetSize( mActorId, mSizeAfterSetting );
- updateProxy.GetPosition( mActorId, mPositionAfterSetting );
- updateProxy.GetColor( mActorId, mColorAfterSetting );
- updateProxy.GetScale( mActorId, mScaleAfterSetting );
+ FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
+ updateProxy.BakeSize(mActorId, mSizeToSet);
+ updateProxy.BakePosition(mActorId, mPositionToSet);
+ updateProxy.BakeColor(mActorId, mColorToSet);
+ updateProxy.BakeScale(mActorId, mScaleToSet);
+ updateProxy.GetSize(mActorId, mSizeAfterSetting);
+ updateProxy.GetPosition(mActorId, mPositionAfterSetting);
+ updateProxy.GetColor(mActorId, mColorAfterSetting);
+ updateProxy.GetScale(mActorId, mScaleAfterSetting);
}
const unsigned int mActorId;
- const Vector3& mSizeToSet;
- const Vector3& mPositionToSet;
- const Vector4& mColorToSet;
- const Vector3& mScaleToSet;
+ const Vector3& mSizeToSet;
+ const Vector3& mPositionToSet;
+ const Vector4& mColorToSet;
+ const Vector3& mScaleToSet;
Vector3 mSizeAfterSetting;
Vector3 mPositionAfterSetting;
class FrameCallbackMultipleActors : public FrameCallbackBasic
{
public:
-
FrameCallbackMultipleActors()
{
}
- virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
+ virtual void Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
{
- FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
- for( auto&& i : mActorIds )
+ FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
+ for(auto&& i : mActorIds)
{
Vector3 position;
Vector3 size;
- updateProxy.GetPositionAndSize( i, position, size );
- mPositions[ i ] = position;
- mSizes[ i ] = size;
+ updateProxy.GetPositionAndSize(i, position, size);
+ mPositions[i] = position;
+ mSizes[i] = size;
}
}
- Vector< unsigned int > mActorIds;
+ Vector<unsigned int> mActorIds;
- std::map< unsigned int, Vector3 > mPositions;
- std::map< unsigned int, Vector3 > mSizes;
+ std::map<unsigned int, Vector3> mPositions;
+ std::map<unsigned int, Vector3> mSizes;
};
class FrameCallbackActorIdCheck : public FrameCallbackBasic
{
public:
-
- FrameCallbackActorIdCheck( unsigned int actorId )
- : mActorId( actorId )
+ FrameCallbackActorIdCheck(unsigned int actorId)
+ : mActorId(actorId)
{
}
- virtual void Update( Dali::UpdateProxy& updateProxy, float elapsedSeconds ) override
+ virtual void Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) override
{
- FrameCallbackBasic::Update( updateProxy, elapsedSeconds );
+ FrameCallbackBasic::Update(updateProxy, elapsedSeconds);
Vector3 vec3;
Vector4 vec4;
- mGetSizeCallSuccess = updateProxy.GetSize( mActorId, vec3 );
- mGetPositionCallSuccess = updateProxy.GetPosition( mActorId, vec3 );
- mGetColorCallSuccess = updateProxy.GetColor( mActorId, vec4 );
- mGetScaleCallSuccess = updateProxy.GetScale( mActorId, vec3 );
- mGetPositionAndSizeCallSuccess = updateProxy.GetPositionAndSize( mActorId, vec3, vec3 );
- mSetSizeCallSuccess = updateProxy.SetSize( mActorId, vec3 );
- mSetPositionCallSuccess = updateProxy.SetPosition( mActorId, vec3 );
- mSetColorCallSuccess = updateProxy.SetColor( mActorId, vec4 );
- mSetScaleCallSuccess = updateProxy.SetScale( mActorId, vec3 );
- mBakeSizeCallSuccess = updateProxy.BakeSize( mActorId, vec3 );
- mBakePositionCallSuccess = updateProxy.BakePosition( mActorId, vec3 );
- mBakeColorCallSuccess = updateProxy.BakeColor( mActorId, vec4 );
- mBakeScaleCallSuccess = updateProxy.BakeScale( mActorId, vec3 );
+ mGetSizeCallSuccess = updateProxy.GetSize(mActorId, vec3);
+ mGetPositionCallSuccess = updateProxy.GetPosition(mActorId, vec3);
+ mGetColorCallSuccess = updateProxy.GetColor(mActorId, vec4);
+ mGetScaleCallSuccess = updateProxy.GetScale(mActorId, vec3);
+ mGetPositionAndSizeCallSuccess = updateProxy.GetPositionAndSize(mActorId, vec3, vec3);
+ mSetSizeCallSuccess = updateProxy.SetSize(mActorId, vec3);
+ mSetPositionCallSuccess = updateProxy.SetPosition(mActorId, vec3);
+ mSetColorCallSuccess = updateProxy.SetColor(mActorId, vec4);
+ mSetScaleCallSuccess = updateProxy.SetScale(mActorId, vec3);
+ mBakeSizeCallSuccess = updateProxy.BakeSize(mActorId, vec3);
+ mBakePositionCallSuccess = updateProxy.BakePosition(mActorId, vec3);
+ mBakeColorCallSuccess = updateProxy.BakeColor(mActorId, vec4);
+ mBakeScaleCallSuccess = updateProxy.BakeScale(mActorId, vec3);
}
virtual void Reset() override
// Up-call
FrameCallbackBasic::Reset();
- mGetSizeCallSuccess = false;
- mGetPositionCallSuccess = false;
- mGetColorCallSuccess = false;
- mGetScaleCallSuccess = false;
+ mGetSizeCallSuccess = false;
+ mGetPositionCallSuccess = false;
+ mGetColorCallSuccess = false;
+ mGetScaleCallSuccess = false;
mGetPositionAndSizeCallSuccess = false;
- mSetSizeCallSuccess = false;
- mSetPositionCallSuccess = false;
- mSetColorCallSuccess = false;
- mSetScaleCallSuccess = false;
- mBakeSizeCallSuccess = false;
- mBakePositionCallSuccess = false;
- mBakeColorCallSuccess = false;
- mBakeScaleCallSuccess = false;
+ mSetSizeCallSuccess = false;
+ mSetPositionCallSuccess = false;
+ mSetColorCallSuccess = false;
+ mSetScaleCallSuccess = false;
+ mBakeSizeCallSuccess = false;
+ mBakePositionCallSuccess = false;
+ mBakeColorCallSuccess = false;
+ mBakeScaleCallSuccess = false;
}
const uint32_t mActorId;
- bool mGetSizeCallSuccess{ false };
- bool mGetPositionCallSuccess{ false };
- bool mGetColorCallSuccess{ false };
- bool mGetScaleCallSuccess{ false };
- bool mGetPositionAndSizeCallSuccess{ false };
- bool mSetSizeCallSuccess{ false };
- bool mSetPositionCallSuccess{ false };
- bool mSetColorCallSuccess{ false };
- bool mSetScaleCallSuccess{ false };
- bool mBakeSizeCallSuccess{ false };
- bool mBakePositionCallSuccess{ false };
- bool mBakeColorCallSuccess{ false };
- bool mBakeScaleCallSuccess{ false };
+ bool mGetSizeCallSuccess{false};
+ bool mGetPositionCallSuccess{false};
+ bool mGetColorCallSuccess{false};
+ bool mGetScaleCallSuccess{false};
+ bool mGetPositionAndSizeCallSuccess{false};
+ bool mSetSizeCallSuccess{false};
+ bool mSetPositionCallSuccess{false};
+ bool mSetColorCallSuccess{false};
+ bool mSetScaleCallSuccess{false};
+ bool mBakeSizeCallSuccess{false};
+ bool mBakePositionCallSuccess{false};
+ bool mBakeColorCallSuccess{false};
+ bool mBakeScaleCallSuccess{false};
};
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
FrameCallbackBasic frameCallback;
Stage stage = Stage::GetCurrent();
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
frameCallback.mCalled = false;
- DevelStage::RemoveFrameCallback( stage, frameCallback );
+ DevelStage::RemoveFrameCallback(stage, frameCallback);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, false, TEST_LOCATION);
END_TEST;
}
// Test to see that the Getters all return the expected values
TestApplication application;
- Vector2 actorSize( 200, 300 );
- Vector4 color( 0.5f, 0.6f, 0.7f, 0.8f );
- Vector3 position( 10.0f, 20.0f, 30.0f );
- Vector3 scale( 2.0f, 4.0f, 6.0f );
+ Vector2 actorSize(200, 300);
+ Vector4 color(0.5f, 0.6f, 0.7f, 0.8f);
+ Vector3 position(10.0f, 20.0f, 30.0f);
+ Vector3 scale(2.0f, 4.0f, 6.0f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::SIZE, actorSize );
- actor.SetProperty( Actor::Property::COLOR, color );
- actor.SetProperty( Actor::Property::POSITION, position );
- actor.SetProperty( Actor::Property::SCALE, scale );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
+ actor.SetProperty(Actor::Property::COLOR, color);
+ actor.SetProperty(Actor::Property::POSITION, position);
+ actor.SetProperty(Actor::Property::SCALE, scale);
Stage stage = Stage::GetCurrent();
- stage.Add( actor );
+ stage.Add(actor);
- FrameCallbackOneActor frameCallback( actor.GetProperty< int >( Actor::Property::ID ) );
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ FrameCallbackOneActor frameCallback(actor.GetProperty<int>(Actor::Property::ID));
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizeGetSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, position, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mPositionGetPositionAndSizeCall, position, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizeGetPositionAndSizeCall, Vector3( actorSize.width, actorSize.height, 0.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mColor, color, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mScale, scale, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizeGetSizeCall, Vector3(actorSize.width, actorSize.height, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mPositionGetPositionCall, position, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mPositionGetPositionAndSizeCall, position, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizeGetPositionAndSizeCall, Vector3(actorSize.width, actorSize.height, 0.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mColor, color, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mScale, scale, TEST_LOCATION);
END_TEST;
}
// Test to see that the setters set the values appropriately
TestApplication application;
- Vector2 actorSize( 200, 300 );
+ Vector2 actorSize(200, 300);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::SIZE, actorSize );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
Stage stage = Stage::GetCurrent();
- stage.Add( actor );
+ stage.Add(actor);
- Vector3 sizeToSet( 1.0f, 2.0f, 3.0f );
- Vector3 positionToSet( 10.0f, 20.0f, 30.0f );
- Vector4 colorToSet( Color::MAGENTA );
- Vector3 scaleToSet( 1.0f, 3.0f, 5.0f );
+ Vector3 sizeToSet(1.0f, 2.0f, 3.0f);
+ Vector3 positionToSet(10.0f, 20.0f, 30.0f);
+ Vector4 colorToSet(Color::MAGENTA);
+ Vector3 scaleToSet(1.0f, 3.0f, 5.0f);
- FrameCallbackSetter frameCallback( actor.GetProperty< int >( Actor::Property::ID ), sizeToSet, positionToSet, colorToSet, scaleToSet );
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ FrameCallbackSetter frameCallback(actor.GetProperty<int>(Actor::Property::ID), sizeToSet, positionToSet, colorToSet, scaleToSet);
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION);
// Ensure the actual actor values haven't changed as we didn't bake the values after removing the callback
- DevelStage::RemoveFrameCallback( stage, frameCallback );
+ DevelStage::RemoveFrameCallback(stage, frameCallback);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), Vector3( actorSize ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), Vector3(actorSize), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
// Render for a couple more frames to ensure the values are reset properly (some values are double-buffered)
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), Vector3( actorSize ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), Vector3(actorSize), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), Vector3( actorSize ), TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), Color::WHITE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), Vector3(actorSize), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), Color::WHITE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
END_TEST;
}
// Test to see that the bake methods bake the values
TestApplication application;
- Vector2 actorSize( 200, 300 );
+ Vector2 actorSize(200, 300);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::SIZE, actorSize );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, actorSize);
Stage stage = Stage::GetCurrent();
- stage.Add( actor );
+ stage.Add(actor);
- Vector3 sizeToSet( 1.0f, 2.0f, 3.0f );
- Vector3 positionToSet( 10.0f, 20.0f, 30.0f );
- Vector4 colorToSet( Color::MAGENTA );
- Vector3 scaleToSet( 1.0f, 3.0f, 5.0f );
+ Vector3 sizeToSet(1.0f, 2.0f, 3.0f);
+ Vector3 positionToSet(10.0f, 20.0f, 30.0f);
+ Vector4 colorToSet(Color::MAGENTA);
+ Vector3 scaleToSet(1.0f, 3.0f, 5.0f);
- FrameCallbackBaker frameCallback( actor.GetProperty< int >( Actor::Property::ID ), sizeToSet, positionToSet, colorToSet, scaleToSet );
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ FrameCallbackBaker frameCallback(actor.GetProperty<int>(Actor::Property::ID), sizeToSet, positionToSet, colorToSet, scaleToSet);
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizeAfterSetting, sizeToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mPositionAfterSetting, positionToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mColorAfterSetting, colorToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mScaleAfterSetting, scaleToSet, TEST_LOCATION);
// Ensure the new values are saved after removing the callback
- DevelStage::RemoveFrameCallback( stage, frameCallback );
+ DevelStage::RemoveFrameCallback(stage, frameCallback);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::POSITION ).Get< Vector3 >(), positionToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SIZE ).Get< Vector3 >(), sizeToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::COLOR ).Get< Vector4 >(), colorToSet, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty( Actor::Property::SCALE ).Get< Vector3 >(), scaleToSet, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::POSITION).Get<Vector3>(), positionToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SIZE).Get<Vector3>(), sizeToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::COLOR).Get<Vector4>(), colorToSet, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty(Actor::Property::SCALE).Get<Vector3>(), scaleToSet, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliFrameCallbackMultipleActors(void)
{
/**
*/
TestApplication application;
- Stage stage = Stage::GetCurrent();
-
- std::map< char, Vector3 > sizes;
- sizes['A'] = Vector3( 50.0f, 50.0f, 0.0f );
- sizes['B'] = Vector3( 100.0f, 100.0f, 0.0f );
- sizes['C'] = Vector3( 150.0f, 150.0f, 0.0f );
- sizes['D'] = Vector3( 200.0f, 200.0f, 0.0f );
- sizes['E'] = Vector3( 250.0f, 250.0f, 0.0f );
- sizes['F'] = Vector3( 300.0f, 300.0f, 0.0f );
- sizes['G'] = Vector3( 350.0f, 350.0f, 0.0f );
- sizes['H'] = Vector3( 400.0f, 350.0f, 0.0f );
-
- std::map< char, Vector3 > positions;
- positions['A'] = Vector3( 0.0f, 1.0f, 2.0f );
- positions['B'] = Vector3( 2.0f, 3.0f, 4.0f );
- positions['C'] = Vector3( 5.0f, 6.0f, 7.0f );
- positions['D'] = Vector3( 8.0f, 9.0f, 10.0f );
- positions['E'] = Vector3( 11.0f, 12.0f, 13.0f );
- positions['F'] = Vector3( 14.0f, 15.0f, 16.0f );
- positions['G'] = Vector3( 17.0f, 18.0f, 19.0f );
- positions['H'] = Vector3( 20.0f, 21.0f, 22.0f );
+ Stage stage = Stage::GetCurrent();
+
+ std::map<char, Vector3> sizes;
+ sizes['A'] = Vector3(50.0f, 50.0f, 0.0f);
+ sizes['B'] = Vector3(100.0f, 100.0f, 0.0f);
+ sizes['C'] = Vector3(150.0f, 150.0f, 0.0f);
+ sizes['D'] = Vector3(200.0f, 200.0f, 0.0f);
+ sizes['E'] = Vector3(250.0f, 250.0f, 0.0f);
+ sizes['F'] = Vector3(300.0f, 300.0f, 0.0f);
+ sizes['G'] = Vector3(350.0f, 350.0f, 0.0f);
+ sizes['H'] = Vector3(400.0f, 350.0f, 0.0f);
+
+ std::map<char, Vector3> positions;
+ positions['A'] = Vector3(0.0f, 1.0f, 2.0f);
+ positions['B'] = Vector3(2.0f, 3.0f, 4.0f);
+ positions['C'] = Vector3(5.0f, 6.0f, 7.0f);
+ positions['D'] = Vector3(8.0f, 9.0f, 10.0f);
+ positions['E'] = Vector3(11.0f, 12.0f, 13.0f);
+ positions['F'] = Vector3(14.0f, 15.0f, 16.0f);
+ positions['G'] = Vector3(17.0f, 18.0f, 19.0f);
+ positions['H'] = Vector3(20.0f, 21.0f, 22.0f);
Actor actorA = Actor::New();
- actorA.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actorA.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorA.SetProperty( Actor::Property::SIZE, sizes['A'] );
- actorA.SetProperty( Actor::Property::POSITION, positions['A'] );
- stage.Add( actorA );
+ actorA.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorA.SetProperty(Actor::Property::SIZE, sizes['A']);
+ actorA.SetProperty(Actor::Property::POSITION, positions['A']);
+ stage.Add(actorA);
Actor actorB = Actor::New();
- actorB.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_RIGHT );
- actorB.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actorB.SetProperty( Actor::Property::SIZE, sizes['B'] );
- actorB.SetProperty( Actor::Property::POSITION, positions['B'] );
- actorA.Add( actorB );
+ actorB.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_RIGHT);
+ actorB.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actorB.SetProperty(Actor::Property::SIZE, sizes['B']);
+ actorB.SetProperty(Actor::Property::POSITION, positions['B']);
+ actorA.Add(actorB);
Actor actorC = Actor::New();
- actorC.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER );
- actorC.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER );
- actorC.SetProperty( Actor::Property::SIZE, sizes['C'] );
- actorC.SetProperty( Actor::Property::POSITION, positions['C'] );
- actorB.Add( actorC );
+ actorC.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER);
+ actorC.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER);
+ actorC.SetProperty(Actor::Property::SIZE, sizes['C']);
+ actorC.SetProperty(Actor::Property::POSITION, positions['C']);
+ actorB.Add(actorC);
Actor actorD = Actor::New();
- actorD.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_RIGHT );
- actorD.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- actorD.SetProperty( Actor::Property::SIZE, sizes['D'] );
- actorD.SetProperty( Actor::Property::POSITION, positions['D'] );
- actorA.Add( actorD );
+ actorD.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_RIGHT);
+ actorD.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ actorD.SetProperty(Actor::Property::SIZE, sizes['D']);
+ actorD.SetProperty(Actor::Property::POSITION, positions['D']);
+ actorA.Add(actorD);
Actor actorE = Actor::New();
- actorE.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT );
- actorE.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
- actorE.SetProperty( Actor::Property::SIZE, sizes['E'] );
- actorE.SetProperty( Actor::Property::POSITION, positions['E'] );
- stage.Add( actorE );
+ actorE.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_LEFT);
+ actorE.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
+ actorE.SetProperty(Actor::Property::SIZE, sizes['E']);
+ actorE.SetProperty(Actor::Property::POSITION, positions['E']);
+ stage.Add(actorE);
Actor actorF = Actor::New();
- actorF.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER );
- actorF.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER );
- actorF.SetProperty( Actor::Property::SIZE, sizes['F'] );
- actorF.SetProperty( Actor::Property::POSITION, positions['F'] );
- actorE.Add( actorF );
+ actorF.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_CENTER);
+ actorF.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_CENTER);
+ actorF.SetProperty(Actor::Property::SIZE, sizes['F']);
+ actorF.SetProperty(Actor::Property::POSITION, positions['F']);
+ actorE.Add(actorF);
Actor actorG = Actor::New();
- actorG.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_RIGHT );
- actorG.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- actorG.SetProperty( Actor::Property::SIZE, sizes['G'] );
- actorG.SetProperty( Actor::Property::POSITION, positions['G'] );
- actorE.Add( actorG );
+ actorG.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER_RIGHT);
+ actorG.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ actorG.SetProperty(Actor::Property::SIZE, sizes['G']);
+ actorG.SetProperty(Actor::Property::POSITION, positions['G']);
+ actorE.Add(actorG);
Actor actorH = Actor::New();
- actorH.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
- actorH.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT );
- actorH.SetProperty( Actor::Property::SIZE, sizes['H'] );
- actorH.SetProperty( Actor::Property::POSITION, positions['H'] );
- actorG.Add( actorH );
-
- std::map< char, unsigned int > actorIds;
- actorIds['A'] = actorA.GetProperty< int >( Actor::Property::ID );
- actorIds['B'] = actorB.GetProperty< int >( Actor::Property::ID );
- actorIds['C'] = actorC.GetProperty< int >( Actor::Property::ID );
- actorIds['D'] = actorD.GetProperty< int >( Actor::Property::ID );
- actorIds['E'] = actorE.GetProperty< int >( Actor::Property::ID );
- actorIds['F'] = actorF.GetProperty< int >( Actor::Property::ID );
- actorIds['G'] = actorG.GetProperty< int >( Actor::Property::ID );
- actorIds['H'] = actorH.GetProperty< int >( Actor::Property::ID );
+ actorH.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
+ actorH.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_LEFT);
+ actorH.SetProperty(Actor::Property::SIZE, sizes['H']);
+ actorH.SetProperty(Actor::Property::POSITION, positions['H']);
+ actorG.Add(actorH);
+
+ std::map<char, unsigned int> actorIds;
+ actorIds['A'] = actorA.GetProperty<int>(Actor::Property::ID);
+ actorIds['B'] = actorB.GetProperty<int>(Actor::Property::ID);
+ actorIds['C'] = actorC.GetProperty<int>(Actor::Property::ID);
+ actorIds['D'] = actorD.GetProperty<int>(Actor::Property::ID);
+ actorIds['E'] = actorE.GetProperty<int>(Actor::Property::ID);
+ actorIds['F'] = actorF.GetProperty<int>(Actor::Property::ID);
+ actorIds['G'] = actorG.GetProperty<int>(Actor::Property::ID);
+ actorIds['H'] = actorH.GetProperty<int>(Actor::Property::ID);
FrameCallbackMultipleActors frameCallback;
- for( auto&& i : actorIds )
+ for(auto&& i : actorIds)
{
- frameCallback.mActorIds.PushBack( i.second );
+ frameCallback.mActorIds.PushBack(i.second);
}
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
- for( char i = 'A'; i <= 'H'; ++i )
+ for(char i = 'A'; i <= 'H'; ++i)
{
- DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mPositions[actorIds[i]], positions[i], TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizes[actorIds[i]], sizes[i], TEST_LOCATION);
}
// Render again to make sure it still gets called and gives the correct values (in case any optimisations break this)
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
- for( char i = 'A'; i <= 'H'; ++i )
+ for(char i = 'A'; i <= 'H'; ++i)
{
- DALI_TEST_EQUALS( frameCallback.mPositions[ actorIds[ i ] ], positions[ i ], TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizes[ actorIds[ i ] ], sizes[ i ], TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mPositions[actorIds[i]], positions[i], TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizes[actorIds[i]], sizes[i], TEST_LOCATION);
}
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 200, 300 ) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(200, 300));
- Stage stage = Stage::GetCurrent();
- FrameCallbackOneActor frameCallback( actor.GetProperty< int >( Actor::Property::ID ) );
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ Stage stage = Stage::GetCurrent();
+ FrameCallbackOneActor frameCallback(actor.GetProperty<int>(Actor::Property::ID));
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
// All should be default constructed objects
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mPositionGetPositionCall, Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSizeGetSizeCall, Vector3::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mColor, Vector4::ZERO, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mScale, Vector3::ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mPositionGetPositionCall, Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSizeGetSizeCall, Vector3::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mColor, Vector4::ZERO, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mScale, Vector3::ZERO, TEST_LOCATION);
END_TEST;
}
// Test to ensure that there are no issues when trying to use the update-proxy methods with an invalid actor ID.
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- FrameCallbackActorIdCheck frameCallback( 10000 );
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ FrameCallbackActorIdCheck frameCallback(10000);
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
// Invalid Actor ID so all the methods should not return successfully.
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION);
END_TEST;
}
// and then re-start calling the required methods if that actor is re-added back to the stage
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
- FrameCallbackActorIdCheck frameCallback( actor.GetProperty< int >( Actor::Property::ID ) );
- DevelStage::AddFrameCallback( stage, frameCallback, stage.GetRootLayer() );
+ FrameCallbackActorIdCheck frameCallback(actor.GetProperty<int>(Actor::Property::ID));
+ DevelStage::AddFrameCallback(stage, frameCallback, stage.GetRootLayer());
application.SendNotification();
application.Render();
// All methods should return successfully.
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION);
frameCallback.Reset();
// Remove the actor from stage, the methods should not return successfully.
- stage.Remove( actor );
+ stage.Remove(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, false, TEST_LOCATION);
frameCallback.Reset();
// Re-add the actor back to the stage, all the methods should once again, return successfully.
- stage.Add( actor );
+ stage.Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetColorCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetColorCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetColorCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetScaleCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mGetPositionAndSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetPositionCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetColorCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mSetScaleCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeSizeCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakePositionCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeColorCallSuccess, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback.mBakeScaleCallSuccess, true, TEST_LOCATION);
END_TEST;
}
// Test to ensure multiple frame-callbacks work as expected
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
FrameCallbackBasic frameCallback1;
FrameCallbackBasic frameCallback2;
- DevelStage::AddFrameCallback( stage, frameCallback1, stage.GetRootLayer() );
- DevelStage::AddFrameCallback( stage, frameCallback2, stage.GetRootLayer() );
+ DevelStage::AddFrameCallback(stage, frameCallback1, stage.GetRootLayer());
+ DevelStage::AddFrameCallback(stage, frameCallback2, stage.GetRootLayer());
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
frameCallback1.Reset();
frameCallback2.Reset();
// Remove the second frame-callback, only the first should be called
- DevelStage::RemoveFrameCallback( stage, frameCallback2 );
+ DevelStage::RemoveFrameCallback(stage, frameCallback2);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
frameCallback1.Reset();
frameCallback2.Reset();
// Re-add the second frame-callback and remove the first, only the second should be called
- DevelStage::AddFrameCallback( stage, frameCallback2, stage.GetRootLayer() );
- DevelStage::RemoveFrameCallback( stage, frameCallback1 );
+ DevelStage::AddFrameCallback(stage, frameCallback2, stage.GetRootLayer());
+ DevelStage::RemoveFrameCallback(stage, frameCallback1);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
frameCallback1.Reset();
frameCallback2.Reset();
// Attempt removal of the first frame-callback again, should be a no-op and yield the exact same results as the last run
- DevelStage::RemoveFrameCallback( stage, frameCallback1 );
+ DevelStage::RemoveFrameCallback(stage, frameCallback1);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
frameCallback1.Reset();
frameCallback2.Reset();
// Remove the second frame-callback as well, neither should be called
- DevelStage::RemoveFrameCallback( stage, frameCallback2 );
+ DevelStage::RemoveFrameCallback(stage, frameCallback2);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
END_TEST;
}
// Test to ensure that the frame-callback behaves gracefully if the connected root-actor is destroyed
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
FrameCallbackBasic frameCallback1;
FrameCallbackBasic frameCallback2;
- DevelStage::AddFrameCallback( stage, frameCallback1, actor );
- DevelStage::AddFrameCallback( stage, frameCallback2, actor );
+ DevelStage::AddFrameCallback(stage, frameCallback1, actor);
+ DevelStage::AddFrameCallback(stage, frameCallback2, actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, true, TEST_LOCATION);
frameCallback1.Reset();
frameCallback2.Reset();
// Remove the second frame-callback, only the first should be called
- DevelStage::RemoveFrameCallback( stage, frameCallback2 );
+ DevelStage::RemoveFrameCallback(stage, frameCallback2);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
frameCallback1.Reset();
frameCallback2.Reset();
// Remove and destroy the actor, the first one should not be called either
- stage.Remove( actor );
+ stage.Remove(actor);
actor.Reset();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback1.mCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( frameCallback2.mCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback1.mCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(frameCallback2.mCalled, false, TEST_LOCATION);
END_TEST;
}
// Ensure there's no segmentation fault if the callback is deleted without being removed
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
{
FrameCallbackBasic frameCallback;
- DevelStage::AddFrameCallback( stage, frameCallback, actor );
+ DevelStage::AddFrameCallback(stage, frameCallback, actor);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( frameCallback.mCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(frameCallback.mCalled, true, TEST_LOCATION);
frameCallback.Reset();
}
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( true ); // If it runs to here then there's no segmentation fault
+ DALI_TEST_CHECK(true); // If it runs to here then there's no segmentation fault
END_TEST;
}
// Ensure we don't connect the same frame-callback twice
TestApplication application;
- Stage stage = Stage::GetCurrent();
- Actor rootActor = stage.GetRootLayer();
+ Stage stage = Stage::GetCurrent();
+ Actor rootActor = stage.GetRootLayer();
FrameCallbackBasic frameCallback;
- DevelStage::AddFrameCallback( stage, frameCallback, rootActor );
+ DevelStage::AddFrameCallback(stage, frameCallback, rootActor);
try
{
- DevelStage::AddFrameCallback( stage, frameCallback, rootActor );
+ DevelStage::AddFrameCallback(stage, frameCallback, rootActor);
}
- catch( ... )
+ catch(...)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
*
*/
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
using namespace Dali;
namespace
{
+struct TexturedQuadVertex
+{
+ Vector2 position;
+ Vector2 textureCoordinates;
+};
-struct TexturedQuadVertex { Vector2 position; Vector2 textureCoordinates; };
-
-VertexBuffer CreateVertexBuffer( const std::string& aPosition, const std::string& aTexCoord )
+VertexBuffer CreateVertexBuffer(const std::string& aPosition, const std::string& aTexCoord)
{
- const float halfQuadSize = .5f;
+ const float halfQuadSize = .5f;
TexturedQuadVertex texturedQuadVertexData[4] = {
- { Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f) },
- { Vector2( halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f) },
- { Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f) },
- { Vector2( halfQuadSize, halfQuadSize), Vector2(1.f, 1.f) } };
+ {Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f)},
+ {Vector2(halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f)},
+ {Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f)},
+ {Vector2(halfQuadSize, halfQuadSize), Vector2(1.f, 1.f)}};
Property::Map vertexFormat;
vertexFormat[aPosition] = Property::VECTOR2;
vertexFormat[aTexCoord] = Property::VECTOR2;
- VertexBuffer vertexData = VertexBuffer::New( vertexFormat );
- vertexData.SetData( texturedQuadVertexData, 4 );
+ VertexBuffer vertexData = VertexBuffer::New(vertexFormat);
+ vertexData.SetData(texturedQuadVertexData, 4);
return vertexData;
}
-
-}
-
+} // namespace
int UtcDaliGeometryNew01(void)
{
Geometry geometry = Geometry::New();
- DALI_TEST_EQUALS( (bool)geometry, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)geometry, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliGeometryNew02(void)
{
TestApplication application;
- Geometry geometry;
- DALI_TEST_EQUALS( (bool)geometry, false, TEST_LOCATION );
+ Geometry geometry;
+ DALI_TEST_EQUALS((bool)geometry, false, TEST_LOCATION);
END_TEST;
}
Geometry geometryCopy(geometry);
- DALI_TEST_EQUALS( (bool)geometryCopy, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)geometryCopy, true, TEST_LOCATION);
END_TEST;
}
Geometry geometry = Geometry::New();
Geometry geometry2;
- DALI_TEST_EQUALS( (bool)geometry2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)geometry2, false, TEST_LOCATION);
geometry2 = geometry;
- DALI_TEST_EQUALS( (bool)geometry2, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)geometry2, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Geometry geometry = Geometry::New();
- DALI_TEST_CHECK( geometry );
- DALI_TEST_EQUALS( 1, geometry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION );
+ DALI_TEST_CHECK(geometry);
+ DALI_TEST_EQUALS(1, geometry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION);
- VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
- geometry.AddVertexBuffer( vertexBuffer );
- DALI_TEST_EQUALS( 1u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION );
+ VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord");
+ geometry.AddVertexBuffer(vertexBuffer);
+ DALI_TEST_EQUALS(1u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION);
- Geometry move = std::move( geometry );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, move.GetNumberOfVertexBuffers(), TEST_LOCATION );
- DALI_TEST_CHECK( !geometry );
+ Geometry move = std::move(geometry);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, move.GetNumberOfVertexBuffers(), TEST_LOCATION);
+ DALI_TEST_CHECK(!geometry);
END_TEST;
}
TestApplication application;
Geometry geometry = Geometry::New();
- DALI_TEST_CHECK( geometry );
- DALI_TEST_EQUALS( 1, geometry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION );
+ DALI_TEST_CHECK(geometry);
+ DALI_TEST_EQUALS(1, geometry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION);
- VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
- geometry.AddVertexBuffer( vertexBuffer );
- DALI_TEST_EQUALS( 1u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION );
+ VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord");
+ geometry.AddVertexBuffer(vertexBuffer);
+ DALI_TEST_EQUALS(1u, geometry.GetNumberOfVertexBuffers(), TEST_LOCATION);
Geometry move;
- move = std::move( geometry );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, move.GetNumberOfVertexBuffers(), TEST_LOCATION );
- DALI_TEST_CHECK( !geometry );
+ move = std::move(geometry);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, move.GetNumberOfVertexBuffers(), TEST_LOCATION);
+ DALI_TEST_CHECK(!geometry);
END_TEST;
}
Geometry geometry = Geometry::New();
BaseHandle handle(geometry);
- Geometry geometry2 = Geometry::DownCast(handle);
- DALI_TEST_EQUALS( (bool)geometry2, true, TEST_LOCATION );
+ Geometry geometry2 = Geometry::DownCast(handle);
+ DALI_TEST_EQUALS((bool)geometry2, true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Handle handle = Handle::New(); // Create a custom object
+ Handle handle = Handle::New(); // Create a custom object
Geometry geometry = Geometry::DownCast(handle);
- DALI_TEST_EQUALS( (bool)geometry, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)geometry, false, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test AddVertexBuffer");
- VertexBuffer vertexBuffer1 = CreateVertexBuffer("aPosition1", "aTexCoord1" );
- Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer1 );
+ VertexBuffer vertexBuffer1 = CreateVertexBuffer("aPosition1", "aTexCoord1");
+ Geometry geometry = Geometry::New();
+ geometry.AddVertexBuffer(vertexBuffer1);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
{
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
- application.GetGlAbstraction().GetBufferDataCalls();
+ application.GetGlAbstraction().GetBufferDataCalls();
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS( bufferDataCalls[0], 4*sizeof( TexturedQuadVertex ), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls[0], 4 * sizeof(TexturedQuadVertex), TEST_LOCATION);
}
// add the second vertex buffer
application.GetGlAbstraction().ResetBufferDataCalls();
- VertexBuffer vertexBuffer2 = CreateVertexBuffer( "aPosition2", "aTexCoord2" );
- geometry.AddVertexBuffer( vertexBuffer2 );
+ VertexBuffer vertexBuffer2 = CreateVertexBuffer("aPosition2", "aTexCoord2");
+ geometry.AddVertexBuffer(vertexBuffer2);
application.SendNotification();
application.Render(0);
application.Render();
{
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
- application.GetGlAbstraction().GetBufferDataCalls();
+ application.GetGlAbstraction().GetBufferDataCalls();
//Check that only the new buffer gets uploaded
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( bufferDataCalls[0], 4*sizeof( TexturedQuadVertex ), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(bufferDataCalls[0], 4 * sizeof(TexturedQuadVertex), TEST_LOCATION);
}
END_TEST;
TestApplication application;
tet_infoline("Test GetNumberOfVertexBuffers");
- VertexBuffer vertexBuffer1 = CreateVertexBuffer("aPosition1", "aTexCoord1" );
- VertexBuffer vertexBuffer2 = CreateVertexBuffer("aPosition2", "aTexCoord2" );
- VertexBuffer vertexBuffer3 = CreateVertexBuffer("aPosition3", "aTexCoord3" );
+ VertexBuffer vertexBuffer1 = CreateVertexBuffer("aPosition1", "aTexCoord1");
+ VertexBuffer vertexBuffer2 = CreateVertexBuffer("aPosition2", "aTexCoord2");
+ VertexBuffer vertexBuffer3 = CreateVertexBuffer("aPosition3", "aTexCoord3");
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer1 );
- DALI_TEST_EQUALS( geometry.GetNumberOfVertexBuffers(), 1u, TEST_LOCATION );
+ geometry.AddVertexBuffer(vertexBuffer1);
+ DALI_TEST_EQUALS(geometry.GetNumberOfVertexBuffers(), 1u, TEST_LOCATION);
- geometry.AddVertexBuffer( vertexBuffer2 );
- geometry.AddVertexBuffer( vertexBuffer3 );
- DALI_TEST_EQUALS( geometry.GetNumberOfVertexBuffers(), 3u, TEST_LOCATION );
+ geometry.AddVertexBuffer(vertexBuffer2);
+ geometry.AddVertexBuffer(vertexBuffer3);
+ DALI_TEST_EQUALS(geometry.GetNumberOfVertexBuffers(), 3u, TEST_LOCATION);
- geometry.RemoveVertexBuffer( 2u );
- DALI_TEST_EQUALS( geometry.GetNumberOfVertexBuffers(), 2u, TEST_LOCATION );
+ geometry.RemoveVertexBuffer(2u);
+ DALI_TEST_EQUALS(geometry.GetNumberOfVertexBuffers(), 2u, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test RemoveVertexBuffer");
- VertexBuffer vertexBuffer1 = CreateVertexBuffer("aPosition1", "aTexCoord1" );
- VertexBuffer vertexBuffer2 = CreateVertexBuffer("aPosition2", "aTexCoord2" );
+ VertexBuffer vertexBuffer1 = CreateVertexBuffer("aPosition1", "aTexCoord1");
+ VertexBuffer vertexBuffer2 = CreateVertexBuffer("aPosition2", "aTexCoord2");
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer1 );
+ geometry.AddVertexBuffer(vertexBuffer1);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
- DALI_TEST_EQUALS( geometry.GetNumberOfVertexBuffers(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(geometry.GetNumberOfVertexBuffers(), 1u, TEST_LOCATION);
- geometry.RemoveVertexBuffer( 0 );
- geometry.AddVertexBuffer( vertexBuffer2 );
- DALI_TEST_EQUALS( geometry.GetNumberOfVertexBuffers(), 1u, TEST_LOCATION );
+ geometry.RemoveVertexBuffer(0);
+ geometry.AddVertexBuffer(vertexBuffer2);
+ DALI_TEST_EQUALS(geometry.GetNumberOfVertexBuffers(), 1u, TEST_LOCATION);
- geometry.RemoveVertexBuffer( 0 );
- DALI_TEST_EQUALS( geometry.GetNumberOfVertexBuffers(), 0u, TEST_LOCATION );
+ geometry.RemoveVertexBuffer(0);
+ DALI_TEST_EQUALS(geometry.GetNumberOfVertexBuffers(), 0u, TEST_LOCATION);
//Todo: test by checking the BufferDataCalls
// make sure the vertex buffer in actually removed from gl
- END_TEST;
+ END_TEST;
}
int UtcDaliGeometrySetIndexBuffer(void)
tet_infoline("Test SetIndexBuffer");
- VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
+ VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord");
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
+ geometry.AddVertexBuffer(vertexBuffer);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
{
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
- application.GetGlAbstraction().GetBufferDataCalls();
+ application.GetGlAbstraction().GetBufferDataCalls();
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS( bufferDataCalls[0], 4*sizeof( TexturedQuadVertex ), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls[0], 4 * sizeof(TexturedQuadVertex), TEST_LOCATION);
}
// Set index buffer
application.GetGlAbstraction().ResetBufferDataCalls();
- const unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
- geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
+ const unsigned short indexData[6] = {0, 3, 1, 0, 2, 3};
+ geometry.SetIndexBuffer(indexData, sizeof(indexData) / sizeof(indexData[0]));
application.SendNotification();
application.Render(0);
application.Render();
{
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
- application.GetGlAbstraction().GetBufferDataCalls();
+ application.GetGlAbstraction().GetBufferDataCalls();
//Only the index buffer should be uploaded
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
// should be unsigned short instead of unsigned int
- DALI_TEST_EQUALS( bufferDataCalls[0], 6*sizeof( unsigned short ), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls[0], 6 * sizeof(unsigned short), TEST_LOCATION);
}
-
END_TEST;
}
tet_infoline("Test SetType and GetType: without index buffer");
- unsigned int numVertex = 4u;
- VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
+ unsigned int numVertex = 4u;
+ VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord");
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
+ geometry.AddVertexBuffer(vertexBuffer);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
/****************************************************/
// Default (TRIANGLES), no index buffer
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// Test the default geometry type is GL_TRIANGLE
// no index buffer, call glDrawArrays,
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
std::stringstream out;
out << GL_TRIANGLES << ", " << 0 << ", " << numVertex;
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::TRIANGLES, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::TRIANGLES, TEST_LOCATION);
/*********************************************************/
// LINES, no index buffer
- geometry.SetType( Geometry::LINES );
+ geometry.SetType(Geometry::LINES);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_LINES
// no index buffer, call glDrawArrays,
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
out.str("");
out << GL_LINES << ", " << 0 << ", " << numVertex;
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::LINES, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::LINES, TEST_LOCATION);
/*****************************************************/
//POINTS
- geometry.SetType( Geometry::POINTS );
+ geometry.SetType(Geometry::POINTS);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_POINTS
// no index buffer, call glDrawArrays,
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
out.str("");
out << GL_POINTS << ", " << 0 << ", " << numVertex;
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::POINTS, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::POINTS, TEST_LOCATION);
/*****************************************************/
//TRIANGLE_STRIP, no index buffer
- geometry.SetType( Geometry::TRIANGLE_STRIP );
+ geometry.SetType(Geometry::TRIANGLE_STRIP);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_TRIANGLE_STRIP
// no index buffer, call glDrawArrays,
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
out.str("");
out << GL_TRIANGLE_STRIP << ", " << 0 << ", " << numVertex;
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::TRIANGLE_STRIP, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::TRIANGLE_STRIP, TEST_LOCATION);
/*****************************************************/
//TRIANGLE_FAN, no index buffer
- geometry.SetType( Geometry::TRIANGLE_FAN );
+ geometry.SetType(Geometry::TRIANGLE_FAN);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_TRIANGLE_FAN
// no index buffer, call glDrawArrays,
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
out.str("");
out << GL_TRIANGLE_FAN << ", " << 0 << ", " << numVertex;
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::TRIANGLE_FAN, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::TRIANGLE_FAN, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test SetType and GetType: with index buffer");
- unsigned int numVertex = 4u;
- unsigned int numIndex = 6u; // 6 unsigned short
- VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord" );
-
+ unsigned int numVertex = 4u;
+ unsigned int numIndex = 6u; // 6 unsigned short
+ VertexBuffer vertexBuffer = CreateVertexBuffer("aPosition", "aTexCoord");
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
- const unsigned short indexData[6] = { 0, 3, 1, 0, 2, 3 };
- geometry.SetIndexBuffer( indexData, sizeof(indexData)/sizeof(indexData[0]) );
+ geometry.AddVertexBuffer(vertexBuffer);
+ const unsigned short indexData[6] = {0, 3, 1, 0, 2, 3};
+ geometry.SetIndexBuffer(indexData, sizeof(indexData) / sizeof(indexData[0]));
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
+ TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
/****************************************************/
// Default (TRIANGLES), with index buffer
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// Test the default geometry type is GL_TRIANGLE
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION);
std::stringstream out;
- out << GL_TRIANGLES << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+ out << GL_TRIANGLES << ", " << numIndex << ", " << GL_UNSIGNED_SHORT << ", "
+ << "indices";
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::TRIANGLES, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::TRIANGLES, TEST_LOCATION);
/*********************************************************/
// LINES, with index buffer
- geometry.SetType( Geometry::LINES );
+ geometry.SetType(Geometry::LINES);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_LINES
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION);
out.str("");
- out << GL_LINES << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+ out << GL_LINES << ", " << numIndex << ", " << GL_UNSIGNED_SHORT << ", "
+ << "indices";
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::LINES, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::LINES, TEST_LOCATION);
/*****************************************************/
//POINTS
- geometry.SetType( Geometry::POINTS );
+ geometry.SetType(Geometry::POINTS);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_POINTS
// As Points does not use the index buffer, call glDrawArrays,
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawArrays" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawArrays"), 2, TEST_LOCATION);
out.str("");
out << GL_POINTS << ", " << 0 << ", " << numVertex;
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawArrays", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::POINTS, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::POINTS, TEST_LOCATION);
/*****************************************************/
//TRIANGLE_STRIP
- geometry.SetType( Geometry::TRIANGLE_STRIP );
+ geometry.SetType(Geometry::TRIANGLE_STRIP);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_TRIANGLE_STRIP
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION);
out.str("");
- out << GL_TRIANGLE_STRIP << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+ out << GL_TRIANGLE_STRIP << ", " << numIndex << ", " << GL_UNSIGNED_SHORT << ", "
+ << "indices";
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::TRIANGLE_STRIP, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::TRIANGLE_STRIP, TEST_LOCATION);
/*****************************************************/
//TRIANGLE_FAN
- geometry.SetType( Geometry::TRIANGLE_FAN );
+ geometry.SetType(Geometry::TRIANGLE_FAN);
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
application.Render();
application.SendNotification();
- drawTrace.Enable( false );
+ drawTrace.Enable(false);
// geometry type is set as GL_TRIANGLE_FAN
- DALI_TEST_EQUALS( drawTrace.CountMethod( "DrawElements" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION);
out.str("");
- out << GL_TRIANGLE_FAN << ", " << numIndex << ", " << GL_UNSIGNED_SHORT<<", "<<"indices";
- DALI_TEST_EQUALS( drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
+ out << GL_TRIANGLE_FAN << ", " << numIndex << ", " << GL_UNSIGNED_SHORT << ", "
+ << "indices";
+ DALI_TEST_EQUALS(drawTrace.TestMethodAndParams(1, "DrawElements", out.str()), true, TEST_LOCATION);
- DALI_TEST_EQUALS( geometry.GetType(), Geometry::TRIANGLE_FAN, TEST_LOCATION);
+ DALI_TEST_EQUALS(geometry.GetType(), Geometry::TRIANGLE_FAN, TEST_LOCATION);
END_TEST;
}
int UtcDaliGeometrySetIndexBufferNegative(void)
{
TestApplication application;
- Dali::Geometry instance;
+ Dali::Geometry instance;
try
{
unsigned short* arg1(nullptr);
- unsigned long arg2(0u);
- instance.SetIndexBuffer(arg1,arg2);
+ unsigned long arg2(0u);
+ instance.SetIndexBuffer(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliGeometryAddVertexBufferNegative(void)
{
TestApplication application;
- Dali::Geometry instance;
+ Dali::Geometry instance;
try
{
Dali::VertexBuffer arg1;
int UtcDaliGeometryRemoveVertexBufferNegative(void)
{
TestApplication application;
- Dali::Geometry instance;
+ Dali::Geometry instance;
try
{
unsigned long arg1(0u);
int UtcDaliGeometrySetTypeNegative(void)
{
TestApplication application;
- Dali::Geometry instance;
+ Dali::Geometry instance;
try
{
Dali::Geometry::Type arg1(Geometry::POINTS);
int UtcDaliGeometryGetNumberOfVertexBuffersNegative(void)
{
TestApplication application;
- Dali::Geometry instance;
+ Dali::Geometry instance;
try
{
instance.GetNumberOfVertexBuffers();
int UtcDaliGeometryGetTypeNegative(void)
{
TestApplication application;
- Dali::Geometry instance;
+ Dali::Geometry instance;
try
{
instance.GetType();
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
+
#include <algorithm>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-
int UtcDaliGestureDetectorConstructorN(void)
{
TestApplication application;
detector.Attach(actor);
tet_result(TET_FAIL);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "detector", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "detector", TEST_LOCATION);
}
END_TEST;
}
detector.Attach(actor);
tet_result(TET_PASS);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_FAIL);
}
END_TEST;
detector2.Attach(actor);
tet_result(TET_PASS);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_FAIL);
}
END_TEST;
GestureDetector detector2 = GestureDetector::DownCast(object);
DALI_TEST_CHECK(detector2);
- GestureDetector detector3 = DownCast< GestureDetector >(object);
+ GestureDetector detector3 = DownCast<GestureDetector>(object);
DALI_TEST_CHECK(detector3);
- BaseHandle unInitializedObject;
+ BaseHandle unInitializedObject;
GestureDetector detector4 = GestureDetector::DownCast(unInitializedObject);
DALI_TEST_CHECK(!detector4);
- GestureDetector detector5 = DownCast< GestureDetector >(unInitializedObject);
+ GestureDetector detector5 = DownCast<GestureDetector>(unInitializedObject);
DALI_TEST_CHECK(!detector5);
END_TEST;
}
bool found = false;
for(size_t i = 0; i < detector.GetAttachedActorCount(); i++)
{
- if( detector.GetAttachedActor(i) == actor )
+ if(detector.GetAttachedActor(i) == actor)
{
tet_result(TET_PASS);
found = true;
detector.Attach(actor);
tet_result(TET_FAIL);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "actor", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
}
END_TEST;
}
bool found = false;
for(size_t i = 0; i < detector.GetAttachedActorCount(); i++)
{
- if( detector.GetAttachedActor(i) == actor )
+ if(detector.GetAttachedActor(i) == actor)
{
tet_result(TET_PASS);
found = true;
found = false;
for(size_t i = 0; i < detector.GetAttachedActorCount(); i++)
{
- if( detector.GetAttachedActor(i) == actor )
+ if(detector.GetAttachedActor(i) == actor)
{
found = true;
}
detector.Detach(actor);
tet_result(TET_FAIL);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "actor", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "actor", TEST_LOCATION);
}
END_TEST;
}
detector.Detach(actor2);
tet_result(TET_PASS);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_FAIL);
}
END_TEST;
detector.Detach(actor);
detector.Detach(actor);
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_FAIL);
}
const unsigned int actorsToAdd = 5;
std::vector<Actor> myActors;
- for (unsigned int i = 0; i < actorsToAdd; ++i)
+ for(unsigned int i = 0; i < actorsToAdd; ++i)
{
Actor actor = Actor::New();
myActors.push_back(actor);
const unsigned int actorsToAdd = 5;
std::vector<Actor> myActors;
- for (unsigned int i = 0; i < actorsToAdd; ++i)
+ for(unsigned int i = 0; i < actorsToAdd; ++i)
{
Actor actor = Actor::New();
myActors.push_back(actor);
{
detector.DetachAll();
}
- catch (DaliException& e)
+ catch(DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_FAIL);
}
END_TEST;
// Attach another five actors
std::vector<Actor> myActors;
- for (unsigned int i = 0; i < 5; ++i)
+ for(unsigned int i = 0; i < 5; ++i)
{
Actor actor = Actor::New();
myActors.push_back(actor);
// Use pinch gesture as that doen't currently have any properties. Will need to change it if default properties are added.
GestureDetector detector = PinchGestureDetector::New();
- DALI_TEST_EQUALS( detector.GetPropertyCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetPropertyCount(), 0u, TEST_LOCATION);
Property::IndexContainer indices;
- detector.GetPropertyIndices( indices );
- DALI_TEST_EQUALS( indices.Size(), 0u, TEST_LOCATION );
+ detector.GetPropertyIndices(indices);
+ DALI_TEST_EQUALS(indices.Size(), 0u, TEST_LOCATION);
- DALI_TEST_EQUALS( detector.IsPropertyWritable( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.IsPropertyAnimatable( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.IsPropertyAConstraintInput( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetPropertyType( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX ), Property::NONE, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetPropertyIndex( "InvalidIndex" ), Property::INVALID_INDEX, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.IsPropertyWritable(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.IsPropertyAnimatable(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.IsPropertyAConstraintInput(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetPropertyType(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX), Property::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetPropertyIndex("InvalidIndex"), Property::INVALID_INDEX, TEST_LOCATION);
- Property::Value propValue = detector.GetProperty( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX );
- DALI_TEST_EQUALS( propValue.GetType(), Property::NONE, TEST_LOCATION );
+ Property::Value propValue = detector.GetProperty(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX);
+ DALI_TEST_EQUALS(propValue.GetType(), Property::NONE, TEST_LOCATION);
- DALI_TEST_CHECK( detector.GetPropertyName( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX ).empty() );
+ DALI_TEST_CHECK(detector.GetPropertyName(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX).empty());
// For coverage only, not testable
- detector.SetProperty( DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX, true );
+ detector.SetProperty(DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX, true);
END_TEST;
}
GestureDetector detector = PinchGestureDetector::New();
- Property::Index index = detector.RegisterProperty( "sceneProperty", 0 );
- DALI_TEST_EQUALS( index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), 0, TEST_LOCATION );
+ Property::Index index = detector.RegisterProperty("sceneProperty", 0);
+ DALI_TEST_EQUALS(index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), 0, TEST_LOCATION);
- detector.SetProperty( index, -123 );
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), -123, TEST_LOCATION );
+ detector.SetProperty(index, -123);
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), -123, TEST_LOCATION);
using Dali::Animation;
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( detector, index ), 99 );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(detector, index), 99);
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), -123, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), -123, TEST_LOCATION);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( 1000 /* 100% progress */);
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), 99, TEST_LOCATION );
+ application.Render(1000 /* 100% progress */);
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), 99, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-#include <typeinfo>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali/devel-api/actors/actor-devel.h>
#include <dali/devel-api/object/handle-devel.h>
+#include <dali/public-api/dali-core.h>
+#include <mesh-builder.h>
+#include <stdlib.h>
+
+#include <iostream>
+#include <typeinfo>
+
#include "dali-test-suite-utils/dali-test-suite-utils.h"
#include "dali-test-suite-utils/test-custom-actor.h"
-#include <mesh-builder.h>
-
using namespace Dali;
void handle_test_startup(void)
namespace
{
-
/// Allows the creation of a BaseObject
class BaseObjectType : public BaseObject
{
{
// object + copy + passedByValue, ref count == 3
DALI_TEST_CHECK(passedByValue);
- if (passedByValue)
+ if(passedByValue)
{
DALI_TEST_EQUALS(3, passedByValue.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
return passedByValue;
}
-} // anon namespace
-
+} // namespace
int UtcDaliHandleConstructorVoid(void)
{
// Copy the object, ref count == 2
Handle copy(object);
DALI_TEST_CHECK(copy);
- if (copy)
+ if(copy)
{
DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
Handle anotherCopy = ImplicitCopyConstructor(copy);
DALI_TEST_CHECK(anotherCopy);
- if (anotherCopy)
+ if(anotherCopy)
{
DALI_TEST_EQUALS(3, anotherCopy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
// anotherCopy out of scope, ref count == 2
DALI_TEST_CHECK(copy);
- if (copy)
+ if(copy)
{
DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
// Initialize a handle, ref count == 1
Handle handle = Actor::New();
- DALI_TEST_EQUALS( 1, handle.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, handle.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- int value( 20 );
- Property::Index index = handle.RegisterProperty( "customProperty", value );
- DALI_TEST_CHECK( handle.GetProperty<int>( index ) == value );
+ int value(20);
+ Property::Index index = handle.RegisterProperty("customProperty", value);
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == value);
// Move the object, ref count == 1
- Handle move = std::move( handle );
- DALI_TEST_CHECK( move );
+ Handle move = std::move(handle);
+ DALI_TEST_CHECK(move);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( move.GetProperty<int>( index ) == value );
- DALI_TEST_CHECK( !handle );
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(move.GetProperty<int>(index) == value);
+ DALI_TEST_CHECK(!handle);
END_TEST;
}
// Initialize a handle, ref count == 1
Handle handle = Actor::New();
- DALI_TEST_EQUALS( 1, handle.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, handle.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- int value( 20 );
- Property::Index index = handle.RegisterProperty( "customProperty", value );
- DALI_TEST_CHECK( handle.GetProperty<int>( index ) == value );
+ int value(20);
+ Property::Index index = handle.RegisterProperty("customProperty", value);
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == value);
// Move the object, ref count == 1
Handle move;
- move = std::move( handle );
- DALI_TEST_CHECK( move );
+ move = std::move(handle);
+ DALI_TEST_CHECK(move);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( move.GetProperty<int>( index ) == value );
- DALI_TEST_CHECK( !handle );
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(move.GetProperty<int>(index) == value);
+ DALI_TEST_CHECK(!handle);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( true == actor.Supports( Handle::DYNAMIC_PROPERTIES ) );
+ DALI_TEST_CHECK(true == actor.Supports(Handle::DYNAMIC_PROPERTIES));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- int defaultPropertyCount( actor.GetPropertyCount() );
+ int defaultPropertyCount(actor.GetPropertyCount());
// Register a dynamic property
- actor.RegisterProperty( "testProperty", float(123.0f) );
- DALI_TEST_CHECK( (defaultPropertyCount + 1u) == actor.GetPropertyCount() );
+ actor.RegisterProperty("testProperty", float(123.0f));
+ DALI_TEST_CHECK((defaultPropertyCount + 1u) == actor.GetPropertyCount());
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( "parentOrigin" == actor.GetPropertyName( Actor::Property::PARENT_ORIGIN ) );
+ DALI_TEST_CHECK("parentOrigin" == actor.GetPropertyName(Actor::Property::PARENT_ORIGIN));
// Register a dynamic property
- std::string name("thisNameShouldMatch");
- Property::Index index = actor.RegisterProperty( name, float(123.0f) );
- DALI_TEST_CHECK( name == actor.GetPropertyName( index ) );
+ std::string name("thisNameShouldMatch");
+ Property::Index index = actor.RegisterProperty(name, float(123.0f));
+ DALI_TEST_CHECK(name == actor.GetPropertyName(index));
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( Actor::Property::PARENT_ORIGIN == actor.GetPropertyIndex("parentOrigin") );
+ DALI_TEST_CHECK(Actor::Property::PARENT_ORIGIN == actor.GetPropertyIndex("parentOrigin"));
// Register a dynamic property
- std::string name("thisNameShouldMatch");
- Property::Index index = actor.RegisterProperty( name, float(123.0f) );
- DALI_TEST_CHECK( index == actor.GetPropertyIndex( name ) );
+ std::string name("thisNameShouldMatch");
+ Property::Index index = actor.RegisterProperty(name, float(123.0f));
+ DALI_TEST_CHECK(index == actor.GetPropertyIndex(name));
END_TEST;
}
Integration::Scene stage = application.GetScene();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
const unsigned int defaultPropertyCount = actor.GetPropertyCount();
application.SendNotification();
application.Render();
- Property::Index key1 = CORE_PROPERTY_MAX_INDEX+1;
- Property::Index key2 = CORE_PROPERTY_MAX_INDEX+2;
+ Property::Index key1 = CORE_PROPERTY_MAX_INDEX + 1;
+ Property::Index key2 = CORE_PROPERTY_MAX_INDEX + 2;
const Vector4 testColor(0.5f, 0.2f, 0.9f, 1.0f);
- const float withFlake(99.f);
+ const float withFlake(99.f);
- Property::Index index1 = actor.RegisterProperty( "MyPropertyOne", Vector3::ONE );
- Property::Index index2 = actor.RegisterProperty( key1, "sideColor", testColor);
- Property::Index index3 = actor.RegisterProperty( "MyPropertyTwo", Vector3::ONE );
- Property::Index index4 = actor.RegisterProperty( key2, "iceCream", withFlake );
- Property::Index index5 = actor.RegisterProperty( "MyPropertyThree", Vector3::ONE );
+ Property::Index index1 = actor.RegisterProperty("MyPropertyOne", Vector3::ONE);
+ Property::Index index2 = actor.RegisterProperty(key1, "sideColor", testColor);
+ Property::Index index3 = actor.RegisterProperty("MyPropertyTwo", Vector3::ONE);
+ Property::Index index4 = actor.RegisterProperty(key2, "iceCream", withFlake);
+ Property::Index index5 = actor.RegisterProperty("MyPropertyThree", Vector3::ONE);
application.SendNotification();
application.Render();
// Test that we can get the property index from the integer key
- Property::Index testIndex1 = actor.GetPropertyIndex( key1 );
- Property::Index testIndex2 = actor.GetPropertyIndex( key2 );
+ Property::Index testIndex1 = actor.GetPropertyIndex(key1);
+ Property::Index testIndex2 = actor.GetPropertyIndex(key2);
- DALI_TEST_EQUALS( index2, testIndex1, TEST_LOCATION );
- DALI_TEST_EQUALS( index4, testIndex2, TEST_LOCATION );
+ DALI_TEST_EQUALS(index2, testIndex1, TEST_LOCATION);
+ DALI_TEST_EQUALS(index4, testIndex2, TEST_LOCATION);
// Test that we keep the same indices on the named properties
Property::Index testIndex = actor.GetPropertyIndex("MyPropertyOne");
testIndex = actor.GetPropertyIndex("iceCream");
DALI_TEST_EQUALS(testIndex, index4, TEST_LOCATION);
- DALI_TEST_EQUALS(defaultPropertyCount+5, actor.GetPropertyCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(defaultPropertyCount + 5, actor.GetPropertyCount(), TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- std::string myName("croydon");
- Property::Index intKey = CORE_PROPERTY_MAX_INDEX+1;
- Property::Value value( Color::GREEN );
- Property::Index myIndex = actor.RegisterProperty( intKey, myName, value );
+ std::string myName("croydon");
+ Property::Index intKey = CORE_PROPERTY_MAX_INDEX + 1;
+ Property::Value value(Color::GREEN);
+ Property::Index myIndex = actor.RegisterProperty(intKey, myName, value);
- DALI_TEST_EQUALS( myIndex, actor.GetPropertyIndex( intKey ), TEST_LOCATION );
+ DALI_TEST_EQUALS(myIndex, actor.GetPropertyIndex(intKey), TEST_LOCATION);
Property::Key key1(myName);
Property::Key key2(intKey);
- DALI_TEST_EQUALS( myIndex, actor.GetPropertyIndex( key1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( myIndex, actor.GetPropertyIndex( key2 ), TEST_LOCATION );
+ DALI_TEST_EQUALS(myIndex, actor.GetPropertyIndex(key1), TEST_LOCATION);
+ DALI_TEST_EQUALS(myIndex, actor.GetPropertyIndex(key2), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliHandleIsPropertyWritable(void)
{
tet_infoline("Positive Test Dali::Handle::IsPropertyWritable()");
Actor actor = Actor::New();
// Actor properties which are writable:
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::PARENT_ORIGIN_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::PARENT_ORIGIN_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::PARENT_ORIGIN_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::ANCHOR_POINT ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::ANCHOR_POINT_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::ANCHOR_POINT_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::ANCHOR_POINT_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SIZE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SIZE_WIDTH ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SIZE_HEIGHT ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SIZE_DEPTH ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::POSITION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::POSITION_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::POSITION_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::POSITION_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::ORIENTATION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SCALE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SCALE_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SCALE_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::SCALE_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::VISIBLE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::COLOR ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::COLOR_RED ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::COLOR_GREEN ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::COLOR_BLUE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::COLOR_ALPHA ) );
- DALI_TEST_CHECK( true == actor.IsPropertyWritable( Actor::Property::OPACITY ) );
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::PARENT_ORIGIN_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::PARENT_ORIGIN_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::PARENT_ORIGIN_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::ANCHOR_POINT));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::ANCHOR_POINT_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::ANCHOR_POINT_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::ANCHOR_POINT_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SIZE));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SIZE_WIDTH));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SIZE_HEIGHT));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SIZE_DEPTH));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::POSITION));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::POSITION_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::POSITION_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::POSITION_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::ORIENTATION));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SCALE));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SCALE_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SCALE_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::SCALE_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::VISIBLE));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::COLOR));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::COLOR_RED));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::COLOR_GREEN));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::COLOR_BLUE));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::COLOR_ALPHA));
+ DALI_TEST_CHECK(true == actor.IsPropertyWritable(Actor::Property::OPACITY));
// World-properties are not writable:
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_POSITION ) );
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_ORIENTATION ) );
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_SCALE ) );
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_COLOR ) );
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_POSITION_X ) );
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_POSITION_Y ) );
- DALI_TEST_CHECK( false == actor.IsPropertyWritable( Actor::Property::WORLD_POSITION_Z ) );
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_POSITION));
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_ORIENTATION));
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_SCALE));
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_COLOR));
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_POSITION_X));
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_POSITION_Y));
+ DALI_TEST_CHECK(false == actor.IsPropertyWritable(Actor::Property::WORLD_POSITION_Z));
END_TEST;
}
Actor actor = Actor::New();
// Actor properties which are animatable:
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::PARENT_ORIGIN_X ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::PARENT_ORIGIN_Y ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::PARENT_ORIGIN_Z ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::ANCHOR_POINT ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::ANCHOR_POINT_X ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::ANCHOR_POINT_Y ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::ANCHOR_POINT_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SIZE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SIZE_WIDTH ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SIZE_HEIGHT ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SIZE_DEPTH ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::POSITION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::POSITION_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::POSITION_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::POSITION_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::ORIENTATION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SCALE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SCALE_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SCALE_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::SCALE_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::VISIBLE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::COLOR ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::COLOR_RED ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::COLOR_GREEN ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::COLOR_BLUE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::COLOR_ALPHA ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAnimatable( Actor::Property::OPACITY ) );
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::PARENT_ORIGIN_X));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::PARENT_ORIGIN_Y));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::PARENT_ORIGIN_Z));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::ANCHOR_POINT));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::ANCHOR_POINT_X));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::ANCHOR_POINT_Y));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::ANCHOR_POINT_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SIZE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SIZE_WIDTH));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SIZE_HEIGHT));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SIZE_DEPTH));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::POSITION));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::POSITION_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::POSITION_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::POSITION_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::ORIENTATION));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SCALE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SCALE_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SCALE_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::SCALE_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::VISIBLE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::COLOR));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::COLOR_RED));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::COLOR_GREEN));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::COLOR_BLUE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::COLOR_ALPHA));
+ DALI_TEST_CHECK(true == actor.IsPropertyAnimatable(Actor::Property::OPACITY));
// World-properties can not be animated
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_POSITION ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_ORIENTATION ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_SCALE ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_COLOR ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_POSITION_X ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_POSITION_Y ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAnimatable( Actor::Property::WORLD_POSITION_Z ) );
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_POSITION));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_ORIENTATION));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_SCALE));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_COLOR));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_POSITION_X));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_POSITION_Y));
+ DALI_TEST_CHECK(false == actor.IsPropertyAnimatable(Actor::Property::WORLD_POSITION_Z));
END_TEST;
}
Actor actor = Actor::New();
// Actor properties which can be used as a constraint input:
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::PARENT_ORIGIN_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::PARENT_ORIGIN_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::PARENT_ORIGIN_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::ANCHOR_POINT ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::ANCHOR_POINT_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::ANCHOR_POINT_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::ANCHOR_POINT_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SIZE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SIZE_WIDTH ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SIZE_HEIGHT ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SIZE_DEPTH ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::POSITION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::POSITION_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::POSITION_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::POSITION_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::ORIENTATION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SCALE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SCALE_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SCALE_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::SCALE_Z ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::VISIBLE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::COLOR ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::COLOR_RED ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::COLOR_GREEN ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::COLOR_BLUE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::COLOR_ALPHA ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::OPACITY ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_POSITION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_ORIENTATION ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_SCALE ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_COLOR ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_POSITION_X ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_POSITION_Y ) );
- DALI_TEST_CHECK( true == actor.IsPropertyAConstraintInput( Actor::Property::WORLD_POSITION_Z ) );
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::PARENT_ORIGIN_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::PARENT_ORIGIN_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::PARENT_ORIGIN_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::ANCHOR_POINT));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::ANCHOR_POINT_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::ANCHOR_POINT_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::ANCHOR_POINT_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SIZE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SIZE_WIDTH));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SIZE_HEIGHT));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SIZE_DEPTH));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::POSITION));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::POSITION_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::POSITION_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::POSITION_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::ORIENTATION));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SCALE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SCALE_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SCALE_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::SCALE_Z));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::VISIBLE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::COLOR));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::COLOR_RED));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::COLOR_GREEN));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::COLOR_BLUE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::COLOR_ALPHA));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::OPACITY));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_POSITION));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_ORIENTATION));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_SCALE));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_COLOR));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_POSITION_X));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_POSITION_Y));
+ DALI_TEST_CHECK(true == actor.IsPropertyAConstraintInput(Actor::Property::WORLD_POSITION_Z));
// Actor properties that cannot be used as a constraint input
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::NAME ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::SENSITIVE ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::LEAVE_REQUIRED ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::INHERIT_ORIENTATION ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::INHERIT_SCALE ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::COLOR_MODE ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::DRAW_MODE ) );
- DALI_TEST_CHECK( false == actor.IsPropertyAConstraintInput( Actor::Property::SIZE_MODE_FACTOR ) );
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::NAME));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::SENSITIVE));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::LEAVE_REQUIRED));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::INHERIT_ORIENTATION));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::INHERIT_SCALE));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::COLOR_MODE));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::DRAW_MODE));
+ DALI_TEST_CHECK(false == actor.IsPropertyAConstraintInput(Actor::Property::SIZE_MODE_FACTOR));
END_TEST;
}
-
int UtcDaliHandleGetPropertyType(void)
{
tet_infoline("Positive Test Dali::Handle::GetPropertyType()");
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( Actor::Property::PARENT_ORIGIN ) );
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( Actor::Property::ANCHOR_POINT ) );
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( Actor::Property::SIZE ) );
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( Actor::Property::POSITION ) );
- DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( Actor::Property::ORIENTATION ) );
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( Actor::Property::SCALE ) );
- DALI_TEST_CHECK( Property::BOOLEAN == actor.GetPropertyType( Actor::Property::VISIBLE ) );
- DALI_TEST_CHECK( Property::VECTOR4 == actor.GetPropertyType( Actor::Property::COLOR ) );
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(Actor::Property::PARENT_ORIGIN));
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(Actor::Property::ANCHOR_POINT));
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(Actor::Property::SIZE));
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(Actor::Property::POSITION));
+ DALI_TEST_CHECK(Property::ROTATION == actor.GetPropertyType(Actor::Property::ORIENTATION));
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(Actor::Property::SCALE));
+ DALI_TEST_CHECK(Property::BOOLEAN == actor.GetPropertyType(Actor::Property::VISIBLE));
+ DALI_TEST_CHECK(Property::VECTOR4 == actor.GetPropertyType(Actor::Property::COLOR));
// Register some dynamic properties
- Property::Index boolIndex = actor.RegisterProperty( "boolProperty", bool(true) );
- Property::Index floatIndex = actor.RegisterProperty( "floatProperty", float(123.0f) );
- Property::Index intIndex = actor.RegisterProperty( "intProperty", 123 );
- Property::Index vector2Index = actor.RegisterProperty( "vector2Property", Vector2(1.0f, 2.0f) );
- Property::Index vector3Index = actor.RegisterProperty( "vector3Property", Vector3(1.0f, 2.0f, 3.0f) );
- Property::Index vector4Index = actor.RegisterProperty( "vector4Property", Vector4(1.0f, 2.0f, 3.0f, 4.0f) );
- Property::Index rotationIndex = actor.RegisterProperty( "rotationProperty", AngleAxis(Degree(180.0f), Vector3::YAXIS) );
-
- DALI_TEST_CHECK( Property::BOOLEAN == actor.GetPropertyType( boolIndex ) );
- DALI_TEST_CHECK( Property::FLOAT == actor.GetPropertyType( floatIndex ) );
- DALI_TEST_CHECK( Property::INTEGER == actor.GetPropertyType( intIndex ) );
- DALI_TEST_CHECK( Property::VECTOR2 == actor.GetPropertyType( vector2Index ) );
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( vector3Index ) );
- DALI_TEST_CHECK( Property::VECTOR4 == actor.GetPropertyType( vector4Index ) );
- DALI_TEST_CHECK( Property::ROTATION == actor.GetPropertyType( rotationIndex ) );
+ Property::Index boolIndex = actor.RegisterProperty("boolProperty", bool(true));
+ Property::Index floatIndex = actor.RegisterProperty("floatProperty", float(123.0f));
+ Property::Index intIndex = actor.RegisterProperty("intProperty", 123);
+ Property::Index vector2Index = actor.RegisterProperty("vector2Property", Vector2(1.0f, 2.0f));
+ Property::Index vector3Index = actor.RegisterProperty("vector3Property", Vector3(1.0f, 2.0f, 3.0f));
+ Property::Index vector4Index = actor.RegisterProperty("vector4Property", Vector4(1.0f, 2.0f, 3.0f, 4.0f));
+ Property::Index rotationIndex = actor.RegisterProperty("rotationProperty", AngleAxis(Degree(180.0f), Vector3::YAXIS));
+
+ DALI_TEST_CHECK(Property::BOOLEAN == actor.GetPropertyType(boolIndex));
+ DALI_TEST_CHECK(Property::FLOAT == actor.GetPropertyType(floatIndex));
+ DALI_TEST_CHECK(Property::INTEGER == actor.GetPropertyType(intIndex));
+ DALI_TEST_CHECK(Property::VECTOR2 == actor.GetPropertyType(vector2Index));
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(vector3Index));
+ DALI_TEST_CHECK(Property::VECTOR4 == actor.GetPropertyType(vector4Index));
+ DALI_TEST_CHECK(Property::ROTATION == actor.GetPropertyType(rotationIndex));
// Non animatable properties
- Property::Index nonAnimStringIndex = actor.RegisterProperty( "manFromDelmonte", std::string("yes"), Property::READ_WRITE);
- Property::Index nonAnimV2Index = actor.RegisterProperty( "v2", Vector2(1.f, 2.f), Property::READ_WRITE);
- Property::Index nonAnimV3Index = actor.RegisterProperty( "v3", Vector3(1.f, 2.f, 3.f), Property::READ_WRITE);
- Property::Index nonAnimV4Index = actor.RegisterProperty( "v4", Vector4(1.f, 2.f, 3.f, 4.f), Property::READ_WRITE);
- Property::Index nonAnimBooleanIndex = actor.RegisterProperty( "bool", true, Property::READ_WRITE);
- Property::Index nonAnimFloatIndex = actor.RegisterProperty( "float", 0.f, Property::READ_WRITE);
- Property::Index nonAnimIntegerIndex = actor.RegisterProperty( "int", 0, Property::READ_WRITE);
-
- DALI_TEST_CHECK( nonAnimStringIndex != Property::INVALID_INDEX );
- DALI_TEST_CHECK( nonAnimV2Index != Property::INVALID_INDEX );
- DALI_TEST_CHECK( nonAnimV3Index != Property::INVALID_INDEX );
- DALI_TEST_CHECK( nonAnimV4Index != Property::INVALID_INDEX );
- DALI_TEST_CHECK( nonAnimBooleanIndex != Property::INVALID_INDEX );
- DALI_TEST_CHECK( nonAnimFloatIndex != Property::INVALID_INDEX );
- DALI_TEST_CHECK( nonAnimIntegerIndex != Property::INVALID_INDEX );
-
- DALI_TEST_CHECK( Property::STRING == actor.GetPropertyType( nonAnimStringIndex ) );
- DALI_TEST_CHECK( Property::VECTOR2 == actor.GetPropertyType( nonAnimV2Index ) );
- DALI_TEST_CHECK( Property::VECTOR3 == actor.GetPropertyType( nonAnimV3Index ) );
- DALI_TEST_CHECK( Property::VECTOR4 == actor.GetPropertyType( nonAnimV4Index ) );
- DALI_TEST_CHECK( Property::BOOLEAN == actor.GetPropertyType( nonAnimBooleanIndex ) );
- DALI_TEST_CHECK( Property::FLOAT == actor.GetPropertyType( nonAnimFloatIndex ) );
- DALI_TEST_CHECK( Property::INTEGER == actor.GetPropertyType( nonAnimIntegerIndex ) );
-
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimStringIndex ) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV2Index ) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV3Index ) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimV4Index ) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimBooleanIndex ) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimFloatIndex ) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable( nonAnimIntegerIndex ) );
-
- DALI_TEST_EQUALS( "yes" , actor.GetProperty( nonAnimStringIndex ).Get<std::string>(), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2(1.f, 2.f) , actor.GetProperty( nonAnimV2Index ).Get<Vector2>(), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3(1.f, 2.f, 3.f) , actor.GetProperty( nonAnimV3Index ).Get<Vector3>(), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector4(1.f, 2.f, 3.f, 4.f) , actor.GetProperty( nonAnimV4Index ).Get<Vector4>(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, actor.GetProperty( nonAnimBooleanIndex ).Get<bool>(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0.f, actor.GetProperty( nonAnimFloatIndex ).Get<float>(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, actor.GetProperty( nonAnimIntegerIndex ).Get<int>(), TEST_LOCATION );
+ Property::Index nonAnimStringIndex = actor.RegisterProperty("manFromDelmonte", std::string("yes"), Property::READ_WRITE);
+ Property::Index nonAnimV2Index = actor.RegisterProperty("v2", Vector2(1.f, 2.f), Property::READ_WRITE);
+ Property::Index nonAnimV3Index = actor.RegisterProperty("v3", Vector3(1.f, 2.f, 3.f), Property::READ_WRITE);
+ Property::Index nonAnimV4Index = actor.RegisterProperty("v4", Vector4(1.f, 2.f, 3.f, 4.f), Property::READ_WRITE);
+ Property::Index nonAnimBooleanIndex = actor.RegisterProperty("bool", true, Property::READ_WRITE);
+ Property::Index nonAnimFloatIndex = actor.RegisterProperty("float", 0.f, Property::READ_WRITE);
+ Property::Index nonAnimIntegerIndex = actor.RegisterProperty("int", 0, Property::READ_WRITE);
+
+ DALI_TEST_CHECK(nonAnimStringIndex != Property::INVALID_INDEX);
+ DALI_TEST_CHECK(nonAnimV2Index != Property::INVALID_INDEX);
+ DALI_TEST_CHECK(nonAnimV3Index != Property::INVALID_INDEX);
+ DALI_TEST_CHECK(nonAnimV4Index != Property::INVALID_INDEX);
+ DALI_TEST_CHECK(nonAnimBooleanIndex != Property::INVALID_INDEX);
+ DALI_TEST_CHECK(nonAnimFloatIndex != Property::INVALID_INDEX);
+ DALI_TEST_CHECK(nonAnimIntegerIndex != Property::INVALID_INDEX);
+
+ DALI_TEST_CHECK(Property::STRING == actor.GetPropertyType(nonAnimStringIndex));
+ DALI_TEST_CHECK(Property::VECTOR2 == actor.GetPropertyType(nonAnimV2Index));
+ DALI_TEST_CHECK(Property::VECTOR3 == actor.GetPropertyType(nonAnimV3Index));
+ DALI_TEST_CHECK(Property::VECTOR4 == actor.GetPropertyType(nonAnimV4Index));
+ DALI_TEST_CHECK(Property::BOOLEAN == actor.GetPropertyType(nonAnimBooleanIndex));
+ DALI_TEST_CHECK(Property::FLOAT == actor.GetPropertyType(nonAnimFloatIndex));
+ DALI_TEST_CHECK(Property::INTEGER == actor.GetPropertyType(nonAnimIntegerIndex));
+
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimStringIndex));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimV2Index));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimV3Index));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimV4Index));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimBooleanIndex));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimFloatIndex));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(nonAnimIntegerIndex));
+
+ DALI_TEST_EQUALS("yes", actor.GetProperty(nonAnimStringIndex).Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(1.f, 2.f), actor.GetProperty(nonAnimV2Index).Get<Vector2>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(1.f, 2.f, 3.f), actor.GetProperty(nonAnimV3Index).Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector4(1.f, 2.f, 3.f, 4.f), actor.GetProperty(nonAnimV4Index).Get<Vector4>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, actor.GetProperty(nonAnimBooleanIndex).Get<bool>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0.f, actor.GetProperty(nonAnimFloatIndex).Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, actor.GetProperty(nonAnimIntegerIndex).Get<int>(), TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Property::Index nonAnimStringIndex = actor.RegisterProperty( "manFromDelmonte", std::string("no"), Property::READ_WRITE);
+ Property::Index nonAnimStringIndex = actor.RegisterProperty("manFromDelmonte", std::string("no"), Property::READ_WRITE);
//// modify writable?
- actor.SetProperty( nonAnimStringIndex, Property::Value("yes") );
+ actor.SetProperty(nonAnimStringIndex, Property::Value("yes"));
- DALI_TEST_CHECK( "yes" == actor.GetProperty( nonAnimStringIndex ).Get<std::string>() );
+ DALI_TEST_CHECK("yes" == actor.GetProperty(nonAnimStringIndex).Get<std::string>());
//// cannot modify read only?
- Property::Index readonly = actor.RegisterProperty( "float", 0.f, Property::READ_ONLY);
+ Property::Index readonly = actor.RegisterProperty("float", 0.f, Property::READ_ONLY);
DALI_TEST_CHECK(!actor.IsPropertyAnimatable(readonly));
DALI_TEST_CHECK(!actor.IsPropertyWritable(readonly));
- actor.SetProperty( readonly, Property::Value(1.f) );
+ actor.SetProperty(readonly, Property::Value(1.f));
// trying to set a read-only property is a no-op
- DALI_TEST_EQUALS( 0.f, actor.GetProperty( readonly ).Get<float>(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0.f, actor.GetProperty(readonly).Get<float>(), TEST_LOCATION);
/// animatable can be set
- Property::Index write_anim = actor.RegisterProperty( "write_float", 0.f, Property::ANIMATABLE);
+ Property::Index write_anim = actor.RegisterProperty("write_float", 0.f, Property::ANIMATABLE);
DALI_TEST_CHECK(actor.IsPropertyAnimatable(write_anim));
DALI_TEST_CHECK(actor.IsPropertyWritable(write_anim));
- actor.SetProperty( write_anim, Property::Value(1.f) );
+ actor.SetProperty(write_anim, Property::Value(1.f));
//// animate a non animatable property throws
- float durationSeconds(2.0f);
+ float durationSeconds(2.0f);
Animation animation = Animation::New(durationSeconds);
- bool relativeValue(true);
+ bool relativeValue(true);
try
{
animation.AnimateBy(Property(actor, nonAnimStringIndex), relativeValue, AlphaFunction::EASE_IN);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property type is not animatable", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property type is not animatable", TEST_LOCATION);
}
- DALI_TEST_EQUALS( "yes", actor.GetProperty( nonAnimStringIndex ).Get<std::string>(), TEST_LOCATION );
+ DALI_TEST_EQUALS("yes", actor.GetProperty(nonAnimStringIndex).Get<std::string>(), TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
- Property::Value value(Property::ARRAY);
+ Property::Value value(Property::ARRAY);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
- array->PushBack( Property::Value( 0.1f ) );
- array->PushBack( "a string" );
- array->PushBack( Property::Value( Vector3(1,2,3) ) );
+ array->PushBack(Property::Value(0.1f));
+ array->PushBack("a string");
+ array->PushBack(Property::Value(Vector3(1, 2, 3)));
- DALI_TEST_EQUALS( 3u, array->Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(3u, array->Count(), TEST_LOCATION);
- Property::Index propertyIndex = actor.RegisterProperty( "composite", value, Property::READ_WRITE );
+ Property::Index propertyIndex = actor.RegisterProperty("composite", value, Property::READ_WRITE);
- Property::Value out = actor.GetProperty( propertyIndex );
+ Property::Value out = actor.GetProperty(propertyIndex);
Property::Array* outArray = out.GetArray();
- DALI_TEST_CHECK( outArray != NULL );
+ DALI_TEST_CHECK(outArray != NULL);
- DALI_TEST_CHECK( Property::FLOAT == outArray->GetElementAt(0).GetType());
- DALI_TEST_CHECK( Property::STRING == outArray->GetElementAt(1).GetType());
- DALI_TEST_CHECK( Property::VECTOR3 == outArray->GetElementAt(2).GetType());
+ DALI_TEST_CHECK(Property::FLOAT == outArray->GetElementAt(0).GetType());
+ DALI_TEST_CHECK(Property::STRING == outArray->GetElementAt(1).GetType());
+ DALI_TEST_CHECK(Property::VECTOR3 == outArray->GetElementAt(2).GetType());
- DALI_TEST_EQUALS( 0.1f, outArray->GetElementAt(0).Get<float>(), TEST_LOCATION);
- DALI_TEST_EQUALS( "a string", outArray->GetElementAt(1).Get<std::string>(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector3(1,2,3), outArray->GetElementAt(2).Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0.1f, outArray->GetElementAt(0).Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS("a string", outArray->GetElementAt(1).Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(1, 2, 3), outArray->GetElementAt(2).Get<Vector3>(), TEST_LOCATION);
// composite types not animatable
bool exception = false;
try
{
- actor.RegisterProperty( "compositemap", value, Property::ANIMATABLE);
+ actor.RegisterProperty("compositemap", value, Property::ANIMATABLE);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
exception = true;
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
}
DALI_TEST_EQUALS(exception, true, TEST_LOCATION);
// Map of maps
Property::Value mapOfMaps(Property::MAP);
- Property::Map* map = mapOfMaps.GetMap();
+ Property::Map* map = mapOfMaps.GetMap();
- map->Insert( "key", Property::Value(Property::MAP) );
- map->Insert( "2key", "a string" );
+ map->Insert("key", Property::Value(Property::MAP));
+ map->Insert("2key", "a string");
- DALI_TEST_EQUALS( "a string", (*map)["2key"].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS("a string", (*map)["2key"].Get<std::string>(), TEST_LOCATION);
Property::Map* innerMap = map->Find("key")->GetMap();
- innerMap->Insert( "subkey", 5.f );
+ innerMap->Insert("subkey", 5.f);
- DALI_TEST_CHECK( NULL != map->Find("key")->GetMap()->Find("subkey") );
- DALI_TEST_EQUALS( 5.f, map->Find("key")->GetMap()->Find("subkey")->Get<float>(), TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map->Find("key")->GetMap()->Find("subkey"));
+ DALI_TEST_EQUALS(5.f, map->Find("key")->GetMap()->Find("subkey")->Get<float>(), TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::Property::PARENT_ORIGIN ).Get<Vector3>() );
+ DALI_TEST_CHECK(ParentOrigin::TOP_LEFT == actor.GetProperty(Actor::Property::PARENT_ORIGIN).Get<Vector3>());
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( ParentOrigin::CENTER == actor.GetProperty( Actor::Property::PARENT_ORIGIN ).Get<Vector3>() );
+ DALI_TEST_CHECK(ParentOrigin::CENTER == actor.GetProperty(Actor::Property::PARENT_ORIGIN).Get<Vector3>());
END_TEST;
}
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.IsPropertyWritable( Actor::Property::WORLD_POSITION ) );
+ DALI_TEST_CHECK(!actor.IsPropertyWritable(Actor::Property::WORLD_POSITION));
// World position is not writable so this is a no-op and should not crash
- actor.SetProperty( Actor::Property::WORLD_POSITION, Vector3(1,2,3) );
+ actor.SetProperty(Actor::Property::WORLD_POSITION, Vector3(1, 2, 3));
END_TEST;
}
Integration::Scene stage = application.GetScene();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
const unsigned int defaultPropertyCount = actor.GetPropertyCount();
application.SendNotification();
application.Render();
- Property::Index index1 = actor.RegisterProperty( "MyProperty", Vector3::ONE );
+ Property::Index index1 = actor.RegisterProperty("MyProperty", Vector3::ONE);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetPropertyCount(), defaultPropertyCount + 1, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( index1 ), Vector3::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetPropertyCount(), defaultPropertyCount + 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index1), Vector3::ONE, TEST_LOCATION);
// No new property should be registered when we call the below function
- Property::Index index2 = actor.RegisterProperty( "MyProperty", Vector3::ZAXIS );
+ Property::Index index2 = actor.RegisterProperty("MyProperty", Vector3::ZAXIS);
application.SendNotification();
application.Render();
-
- DALI_TEST_EQUALS( index1, index2, TEST_LOCATION ); // We should have the same index as per the first registration
- DALI_TEST_EQUALS( actor.GetPropertyCount(), defaultPropertyCount + 1, TEST_LOCATION ); // Property count should be the same
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( index2 ), Vector3::ZAXIS, TEST_LOCATION ); // Value should be what we sent on second RegisterProperty call
+ DALI_TEST_EQUALS(index1, index2, TEST_LOCATION); // We should have the same index as per the first registration
+ DALI_TEST_EQUALS(actor.GetPropertyCount(), defaultPropertyCount + 1, TEST_LOCATION); // Property count should be the same
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index2), Vector3::ZAXIS, TEST_LOCATION); // Value should be what we sent on second RegisterProperty call
END_TEST;
}
Integration::Scene stage = application.GetScene();
Actor actor = Actor::New();
- stage.Add( actor );
+ stage.Add(actor);
const unsigned int defaultPropertyCount = actor.GetPropertyCount();
application.SendNotification();
application.Render();
- Property::Index key1 = CORE_PROPERTY_MAX_INDEX+1;
- Property::Index key2 = CORE_PROPERTY_MAX_INDEX+2;
+ Property::Index key1 = CORE_PROPERTY_MAX_INDEX + 1;
+ Property::Index key2 = CORE_PROPERTY_MAX_INDEX + 2;
const Vector4 testColor(0.5f, 0.2f, 0.9f, 1.0f);
- const float withFlake(99.f);
+ const float withFlake(99.f);
- Property::Index index1 = actor.RegisterProperty( "MyPropertyOne", Vector3::ONE );
- Property::Index index2 = actor.RegisterProperty( key1, "sideColor", testColor);
- Property::Index index3 = actor.RegisterProperty( key2, "iceCream", withFlake );
+ Property::Index index1 = actor.RegisterProperty("MyPropertyOne", Vector3::ONE);
+ Property::Index index2 = actor.RegisterProperty(key1, "sideColor", testColor);
+ Property::Index index3 = actor.RegisterProperty(key2, "iceCream", withFlake);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( actor.GetPropertyCount(), defaultPropertyCount + 3, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector3 >( index1 ), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( index2 ), testColor, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty< float >( index3 ), withFlake, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetPropertyCount(), defaultPropertyCount + 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(index1), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index2), testColor, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index3), withFlake, TEST_LOCATION);
// No new property should be registered when we call the below functions
- Property::Index testIndex2 = actor.RegisterProperty( "iceCream", 2200.f );
- Property::Index testIndex1 = actor.RegisterProperty( "sideColor", Color::BLACK );
+ Property::Index testIndex2 = actor.RegisterProperty("iceCream", 2200.f);
+ Property::Index testIndex1 = actor.RegisterProperty("sideColor", Color::BLACK);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( index2, testIndex1, TEST_LOCATION ); // We should have the same index as per the first registration
- DALI_TEST_EQUALS( index3, testIndex2, TEST_LOCATION ); // We should have the same index as per the first registration
- DALI_TEST_EQUALS( actor.GetPropertyCount(), defaultPropertyCount + 3, TEST_LOCATION ); // Property count should be the same
- DALI_TEST_EQUALS( actor.GetProperty< Vector4 >( index2 ), Color::BLACK, TEST_LOCATION ); // Value should be what we sent on second RegisterProperty call
- DALI_TEST_EQUALS( actor.GetProperty< float >( index3 ), 2200.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(index2, testIndex1, TEST_LOCATION); // We should have the same index as per the first registration
+ DALI_TEST_EQUALS(index3, testIndex2, TEST_LOCATION); // We should have the same index as per the first registration
+ DALI_TEST_EQUALS(actor.GetPropertyCount(), defaultPropertyCount + 3, TEST_LOCATION); // Property count should be the same
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(index2), Color::BLACK, TEST_LOCATION); // Value should be what we sent on second RegisterProperty call
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index3), 2200.f, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliHandleGetProperty(void)
{
tet_infoline("Positive Test Dali::Handle::GetProperty()");
Actor actor = Actor::New();
- DALI_TEST_CHECK( ParentOrigin::TOP_LEFT == actor.GetProperty( Actor::Property::PARENT_ORIGIN ).Get<Vector3>() );
- DALI_TEST_CHECK( AnchorPoint::CENTER == actor.GetProperty( Actor::Property::ANCHOR_POINT ).Get<Vector3>() );
- DALI_TEST_CHECK( Vector3::ZERO == actor.GetProperty( Actor::Property::SIZE ).Get<Vector3>() );
- DALI_TEST_CHECK( Vector3::ZERO == actor.GetProperty( Actor::Property::POSITION ).Get<Vector3>() );
- DALI_TEST_CHECK( Vector3::ONE == actor.GetProperty( Actor::Property::SCALE ).Get<Vector3>() );
- DALI_TEST_CHECK( true == actor.GetProperty( Actor::Property::VISIBLE ).Get<bool>() );
- DALI_TEST_CHECK( Color::WHITE == actor.GetProperty( Actor::Property::COLOR ).Get<Vector4>() );
+ DALI_TEST_CHECK(ParentOrigin::TOP_LEFT == actor.GetProperty(Actor::Property::PARENT_ORIGIN).Get<Vector3>());
+ DALI_TEST_CHECK(AnchorPoint::CENTER == actor.GetProperty(Actor::Property::ANCHOR_POINT).Get<Vector3>());
+ DALI_TEST_CHECK(Vector3::ZERO == actor.GetProperty(Actor::Property::SIZE).Get<Vector3>());
+ DALI_TEST_CHECK(Vector3::ZERO == actor.GetProperty(Actor::Property::POSITION).Get<Vector3>());
+ DALI_TEST_CHECK(Vector3::ONE == actor.GetProperty(Actor::Property::SCALE).Get<Vector3>());
+ DALI_TEST_CHECK(true == actor.GetProperty(Actor::Property::VISIBLE).Get<bool>());
+ DALI_TEST_CHECK(Color::WHITE == actor.GetProperty(Actor::Property::COLOR).Get<Vector4>());
END_TEST;
}
Handle handle = Handle::DownCast(baseHandle);
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
baseHandle = BaseHandle();
handle = Handle::DownCast(baseHandle);
- DALI_TEST_CHECK( !handle );
+ DALI_TEST_CHECK(!handle);
END_TEST;
}
TestApplication application;
// BaseObject is NOT an Object, so this DownCast should fail
- BaseHandle handle( new BaseObjectType );
- Handle customHandle1 = Handle::DownCast( handle );
- DALI_TEST_CHECK( ! customHandle1 );
+ BaseHandle handle(new BaseObjectType);
+ Handle customHandle1 = Handle::DownCast(handle);
+ DALI_TEST_CHECK(!customHandle1);
// A DownCast on an empty handle will also fail
Handle empty;
- Handle customHandle2 = Handle::DownCast( empty );
- DALI_TEST_CHECK( ! customHandle2 );
+ Handle customHandle2 = Handle::DownCast(empty);
+ DALI_TEST_CHECK(!customHandle2);
END_TEST;
}
int UtcDaliHandleGetPropertyIndices(void)
{
- TestApplication application;
+ TestApplication application;
Property::IndexContainer indices;
// Actor
Actor actor = Actor::New();
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
int numDefaultProperties = indices.Size();
- DALI_TEST_CHECK( numDefaultProperties > 0 );
- DALI_TEST_EQUALS( numDefaultProperties, actor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(numDefaultProperties > 0);
+ DALI_TEST_EQUALS(numDefaultProperties, actor.GetPropertyCount(), TEST_LOCATION);
const Vector4 testColor(0.5f, 0.2f, 0.9f, 1.0f);
- const float withFlake(99.f);
+ const float withFlake(99.f);
- Property::Index key1 = CORE_PROPERTY_MAX_INDEX+1;
- Property::Index key2 = CORE_PROPERTY_MAX_INDEX+2;
+ Property::Index key1 = CORE_PROPERTY_MAX_INDEX + 1;
+ Property::Index key2 = CORE_PROPERTY_MAX_INDEX + 2;
- actor.RegisterProperty( "MyPropertyOne", Vector3::ONE );
- actor.RegisterProperty( key1, "sideColor", testColor);
- actor.RegisterProperty( "MyPropertyTwo", 1234 );
- Property::Index index4 = actor.RegisterProperty( key2, "iceCream", withFlake );
- actor.RegisterProperty( "MyPropertyThree", Vector2(.2f,.7f) );
+ actor.RegisterProperty("MyPropertyOne", Vector3::ONE);
+ actor.RegisterProperty(key1, "sideColor", testColor);
+ actor.RegisterProperty("MyPropertyTwo", 1234);
+ Property::Index index4 = actor.RegisterProperty(key2, "iceCream", withFlake);
+ actor.RegisterProperty("MyPropertyThree", Vector2(.2f, .7f));
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
- DALI_TEST_EQUALS( indices.Size(), numDefaultProperties + 5, TEST_LOCATION );
- DALI_TEST_EQUALS( indices[indices.Size()-2], index4, TEST_LOCATION );
+ DALI_TEST_EQUALS(indices.Size(), numDefaultProperties + 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(indices[indices.Size() - 2], index4, TEST_LOCATION);
END_TEST;
}
struct PropertyTypeAnimatable
{
- const char * name;
+ const char* name;
Property::Value value;
- bool animatable;
+ bool animatable;
};
Property::Array array;
- Property::Map map;
+ Property::Map map;
PropertyTypeAnimatable properties[] =
+ {
+ {"Property::BOOLEAN", true, true},
+ {"Property::FLOAT", 1.0f, true},
+ {"Property::INTEGER", 1, true},
+ {"Property::VECTOR2", Vector2::ONE, true},
+ {"Property::VECTOR3", Vector3::ONE, true},
+ {"Property::VECTOR4", Vector4::ONE, true},
+ {"Property::MATRIX3", Matrix3::IDENTITY, true},
+ {"Property::MATRIX", Matrix::IDENTITY, true},
+ {"Property::RECTANGLE", Rect<int>(), false},
+ {"Property::ROTATION", AngleAxis(), true},
+ {"Property::STRING", std::string("Me"), false},
+ {"Property::ARRAY", array, false},
+ {"Property::MAP", map, false},
+ };
+
+ unsigned int numOfProperties(sizeof(properties) / sizeof(properties[0]));
+
+ for(unsigned int i = 0; i < numOfProperties; ++i)
{
- { "Property::BOOLEAN", true, true },
- { "Property::FLOAT", 1.0f, true },
- { "Property::INTEGER", 1, true },
- { "Property::VECTOR2", Vector2::ONE, true },
- { "Property::VECTOR3", Vector3::ONE, true },
- { "Property::VECTOR4", Vector4::ONE, true },
- { "Property::MATRIX3", Matrix3::IDENTITY, true },
- { "Property::MATRIX", Matrix::IDENTITY, true },
- { "Property::RECTANGLE", Rect<int>(), false },
- { "Property::ROTATION", AngleAxis(), true },
- { "Property::STRING", std::string("Me"), false },
- { "Property::ARRAY", array, false },
- { "Property::MAP", map, false },
- };
-
- unsigned int numOfProperties( sizeof( properties ) / sizeof( properties[0] ) );
-
- for ( unsigned int i = 0; i < numOfProperties; ++i )
- {
- tet_printf( "Testing: %s\n", properties[i].name );
+ tet_printf("Testing: %s\n", properties[i].name);
bool exception = false;
try
{
Actor actor = Actor::New();
- actor.RegisterProperty( "manFromDelmonte", properties[i].value );
+ actor.RegisterProperty("manFromDelmonte", properties[i].value);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
exception = true;
}
- DALI_TEST_CHECK( properties[i].animatable != exception );
+ DALI_TEST_CHECK(properties[i].animatable != exception);
}
END_TEST;
}
Handle handle = Handle::New();
- float startValue(1.0f);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ float startValue(1.0f);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
- handle.SetProperty( index, 5.0f );
+ handle.SetProperty(index, 5.0f);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == 5.0f );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == 5.0f);
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == 5.0f );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == 5.0f);
END_TEST;
}
Handle handle = Handle::New();
- Property::Value value( Property::NONE );
- Property::Index index = handle.RegisterProperty( "testProperty", value, Property::READ_WRITE);
+ Property::Value value(Property::NONE);
+ Property::Index index = handle.RegisterProperty("testProperty", value, Property::READ_WRITE);
// Negative test i.e. setting a property of type NONE is meaningless
- handle.SetProperty( index, 5.0f );
+ handle.SetProperty(index, 5.0f);
- DALI_TEST_CHECK( true ); // got here without crashing
+ DALI_TEST_CHECK(true); // got here without crashing
END_TEST;
}
Handle handle = Handle::New();
- float startValue(5.0f);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ float startValue(5.0f);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
- handle.SetProperty( index, int(1) );
+ handle.SetProperty(index, int(1));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == 1.0f );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == 1.0f);
END_TEST;
}
Handle handle = Handle::New();
- int startValue(5);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<int>(index) == startValue );
+ int startValue(5);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<int>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == startValue);
- handle.SetProperty( index, float(1.5) );
+ handle.SetProperty(index, float(1.5));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<int>(index) == 1 );
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == 1);
END_TEST;
}
Handle handle = Handle::New();
- Rect<int> startValue(1,2,3,4);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue, Property::READ_WRITE);
- DALI_TEST_EQUALS( handle.GetProperty< Rect<int> >( index ), startValue, TEST_LOCATION );
+ Rect<int> startValue(1, 2, 3, 4);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue, Property::READ_WRITE);
+ DALI_TEST_EQUALS(handle.GetProperty<Rect<int> >(index), startValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< Rect<int> >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<Rect<int> >(index), startValue, TEST_LOCATION);
// Negative test i.e. there is no conversion from float to Rect
- handle.SetProperty( index, float(1.5) );
+ handle.SetProperty(index, float(1.5));
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< Rect<int> >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<Rect<int> >(index), startValue, TEST_LOCATION);
// Positive test (sanity check)
- Rect<int> endValue(5,6,7,8);
- handle.SetProperty( index, endValue );
- DALI_TEST_EQUALS( handle.GetProperty< Rect<int> >( index ), endValue, TEST_LOCATION );
+ Rect<int> endValue(5, 6, 7, 8);
+ handle.SetProperty(index, endValue);
+ DALI_TEST_EQUALS(handle.GetProperty<Rect<int> >(index), endValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< Rect<int> >( index ), endValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<Rect<int> >(index), endValue, TEST_LOCATION);
END_TEST;
}
Handle handle = Handle::New();
- std::string startValue( "Libraries gave us power" );
- Property::Index index = handle.RegisterProperty( "testProperty", startValue, Property::READ_WRITE);
- DALI_TEST_EQUALS( handle.GetProperty< std::string >( index ), startValue, TEST_LOCATION );
+ std::string startValue("Libraries gave us power");
+ Property::Index index = handle.RegisterProperty("testProperty", startValue, Property::READ_WRITE);
+ DALI_TEST_EQUALS(handle.GetProperty<std::string>(index), startValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< std::string >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<std::string>(index), startValue, TEST_LOCATION);
// No conversion from Vector3 to std::string, therefore this should be a NOOP
- handle.SetProperty( index, Vector3(1,2,3) );
+ handle.SetProperty(index, Vector3(1, 2, 3));
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< std::string >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<std::string>(index), startValue, TEST_LOCATION);
// Positive test (sanity check)
- std::string endValue( "Then work came and made us free" );
- handle.SetProperty( index, endValue );
- DALI_TEST_EQUALS( handle.GetProperty< std::string >( index ), endValue, TEST_LOCATION );
+ std::string endValue("Then work came and made us free");
+ handle.SetProperty(index, endValue);
+ DALI_TEST_EQUALS(handle.GetProperty<std::string>(index), endValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< std::string >( index ), endValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<std::string>(index), endValue, TEST_LOCATION);
END_TEST;
}
Handle handle = Handle::New();
- Property::Value value( Property::ARRAY );
- std::string startValue( "The future teaches you to be alone" );
- value.GetArray()->PushBack( startValue );
+ Property::Value value(Property::ARRAY);
+ std::string startValue("The future teaches you to be alone");
+ value.GetArray()->PushBack(startValue);
- Property::Index index = handle.RegisterProperty( "testProperty", value, Property::READ_WRITE);
- Property::Array check1 = handle.GetProperty< Property::Array >( index );
- DALI_TEST_EQUALS( check1.GetElementAt(0).Get<std::string>(), startValue, TEST_LOCATION );
+ Property::Index index = handle.RegisterProperty("testProperty", value, Property::READ_WRITE);
+ Property::Array check1 = handle.GetProperty<Property::Array>(index);
+ DALI_TEST_EQUALS(check1.GetElementAt(0).Get<std::string>(), startValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- Property::Array check2 = handle.GetProperty< Property::Array >( index );
- DALI_TEST_EQUALS( check2.GetElementAt(0).Get<std::string>(), startValue, TEST_LOCATION );
+ Property::Array check2 = handle.GetProperty<Property::Array>(index);
+ DALI_TEST_EQUALS(check2.GetElementAt(0).Get<std::string>(), startValue, TEST_LOCATION);
// No conversion from int to ARRAY, therefore this should be a NOOP
- handle.SetProperty( index, int(2) );
+ handle.SetProperty(index, int(2));
application.SendNotification();
application.Render(0);
- Property::Array check3 = handle.GetProperty< Property::Array >( index );
- DALI_TEST_EQUALS( check3.GetElementAt(0).Get<std::string>(), startValue, TEST_LOCATION );
+ Property::Array check3 = handle.GetProperty<Property::Array>(index);
+ DALI_TEST_EQUALS(check3.GetElementAt(0).Get<std::string>(), startValue, TEST_LOCATION);
// Positive test (sanity check)
Property::Value value2(Property::ARRAY);
- std::string endValue( "The present to be afraid and cold" );
- value2.GetArray()->PushBack( endValue );
- handle.SetProperty( index, value2 );
+ std::string endValue("The present to be afraid and cold");
+ value2.GetArray()->PushBack(endValue);
+ handle.SetProperty(index, value2);
- Property::Array check4 = handle.GetProperty< Property::Array >( index );
- DALI_TEST_EQUALS( check4.GetElementAt(0).Get<std::string>(), endValue, TEST_LOCATION );
+ Property::Array check4 = handle.GetProperty<Property::Array>(index);
+ DALI_TEST_EQUALS(check4.GetElementAt(0).Get<std::string>(), endValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- Property::Array check5 = handle.GetProperty< Property::Array >( index );
- DALI_TEST_EQUALS( check5.GetElementAt(0).Get<std::string>(), endValue, TEST_LOCATION );
+ Property::Array check5 = handle.GetProperty<Property::Array>(index);
+ DALI_TEST_EQUALS(check5.GetElementAt(0).Get<std::string>(), endValue, TEST_LOCATION);
END_TEST;
}
Handle handle = Handle::New();
- Property::Value value( Property::MAP );
- std::string startValue( "Culture sucks down words" );
- value.GetMap()->Insert( "1", startValue );
+ Property::Value value(Property::MAP);
+ std::string startValue("Culture sucks down words");
+ value.GetMap()->Insert("1", startValue);
- Property::Index index = handle.RegisterProperty( "testProperty", value, Property::READ_WRITE );
- Property::Value* check1 = handle.GetProperty< Property::Map >( index ).Find("1");
- DALI_TEST_CHECK( NULL != check1 );
+ Property::Index index = handle.RegisterProperty("testProperty", value, Property::READ_WRITE);
+ Property::Value* check1 = handle.GetProperty<Property::Map>(index).Find("1");
+ DALI_TEST_CHECK(NULL != check1);
// No conversion from float to MAP, therefore this should be a NOOP
- handle.SetProperty( index, float(3.0) );
+ handle.SetProperty(index, float(3.0));
// Positive test (sanity check)
- Property::Value value2( Property::MAP );
- std::string endValue( "Itemise loathing and feed yourself smiles" );
- value.GetMap()->Insert( "1", endValue );
- handle.SetProperty( index, value2 );
+ Property::Value value2(Property::MAP);
+ std::string endValue("Itemise loathing and feed yourself smiles");
+ value.GetMap()->Insert("1", endValue);
+ handle.SetProperty(index, value2);
END_TEST;
}
Handle handle = Handle::New();
- Extents startValue(1,2,3,4);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue, Property::READ_WRITE);
- DALI_TEST_EQUALS( handle.GetProperty< Extents >( index ), startValue, TEST_LOCATION );
+ Extents startValue(1, 2, 3, 4);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue, Property::READ_WRITE);
+ DALI_TEST_EQUALS(handle.GetProperty<Extents>(index), startValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< Extents >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<Extents>(index), startValue, TEST_LOCATION);
// Negative test i.e. there is no conversion from float to Extents
- handle.SetProperty( index, float(1.5) );
+ handle.SetProperty(index, float(1.5));
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< Extents >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<Extents>(index), startValue, TEST_LOCATION);
// Positive test (sanity check)
- Extents endValue(5,6,7,8);
- handle.SetProperty( index, endValue );
- DALI_TEST_EQUALS( handle.GetProperty< Extents >( index ), endValue, TEST_LOCATION );
+ Extents endValue(5, 6, 7, 8);
+ handle.SetProperty(index, endValue);
+ DALI_TEST_EQUALS(handle.GetProperty<Extents>(index), endValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< Extents >( index ), endValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<Extents>(index), endValue, TEST_LOCATION);
END_TEST;
}
Handle handle = Handle::New();
- bool startValue(true);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue, Property::READ_WRITE);
- DALI_TEST_EQUALS( handle.GetProperty< bool >( index ), startValue, TEST_LOCATION );
+ bool startValue(true);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue, Property::READ_WRITE);
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(index), startValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< bool >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(index), startValue, TEST_LOCATION);
// Negative test i.e. there is no conversion from float to bool
- handle.SetProperty( index, float(0.0) );
+ handle.SetProperty(index, float(0.0));
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< bool >( index ), startValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(index), startValue, TEST_LOCATION);
// Positive test (sanity check)
bool endValue(false);
- handle.SetProperty( index, endValue );
- DALI_TEST_EQUALS( handle.GetProperty< bool >( index ), endValue, TEST_LOCATION );
+ handle.SetProperty(index, endValue);
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(index), endValue, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( handle.GetProperty< bool >( index ), endValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(index), endValue, TEST_LOCATION);
END_TEST;
}
Handle handle = Handle::New();
- int startValue(5);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<int>(index) == startValue );
+ int startValue(5);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<int>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == startValue);
// Negative test i.e. there is no conversion from Vector3 to int
- handle.SetProperty( index, Vector3(1,2,3) );
+ handle.SetProperty(index, Vector3(1, 2, 3));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<int>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<int>(index) == startValue);
END_TEST;
}
Handle handle = Handle::New();
- float startValue(5.0);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ float startValue(5.0);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
// Negative test i.e. there is no conversion from Vector3 to float
- handle.SetProperty( index, Vector3(1,2,3) );
+ handle.SetProperty(index, Vector3(1, 2, 3));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<float>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<float>(index) == startValue);
END_TEST;
}
Handle handle = Handle::New();
- Quaternion startValue( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<Quaternion>(index) == startValue );
+ Quaternion startValue(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<Quaternion>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<Quaternion>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<Quaternion>(index) == startValue);
// Negative test i.e. there is no conversion from float to Quaternion
- handle.SetProperty( index, float(7.0) );
+ handle.SetProperty(index, float(7.0));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<Quaternion>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<Quaternion>(index) == startValue);
// Positive test (sanity check)
- Quaternion endValue( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- handle.SetProperty( index, endValue );
- DALI_TEST_CHECK( handle.GetProperty<Quaternion>(index) == endValue );
+ Quaternion endValue(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ handle.SetProperty(index, endValue);
+ DALI_TEST_CHECK(handle.GetProperty<Quaternion>(index) == endValue);
END_TEST;
}
Handle handle = Handle::New();
- Quaternion rotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- Matrix startValue(rotation);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<Matrix>(index) == startValue );
+ Quaternion rotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ Matrix startValue(rotation);
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<Matrix>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<Matrix>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<Matrix>(index) == startValue);
// Negative test i.e. there is no conversion from float to Matrix
- handle.SetProperty( index, float(7.0) );
+ handle.SetProperty(index, float(7.0));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<Matrix>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<Matrix>(index) == startValue);
// Positive test (sanity check)
- Quaternion endRotation( Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
- Matrix endValue(endRotation);
- handle.SetProperty( index, endValue );
- DALI_TEST_CHECK( handle.GetProperty<Matrix>(index) == endValue );
+ Quaternion endRotation(Radian(0.785f), Vector3(1.0f, 1.0f, 0.0f));
+ Matrix endValue(endRotation);
+ handle.SetProperty(index, endValue);
+ DALI_TEST_CHECK(handle.GetProperty<Matrix>(index) == endValue);
END_TEST;
}
Handle handle = Handle::New();
- Matrix3 startValue(11,12,13,
- 21,22,23,
- 31,32,33);
+ Matrix3 startValue(11, 12, 13, 21, 22, 23, 31, 32, 33);
- Property::Index index = handle.RegisterProperty( "testProperty", startValue );
- DALI_TEST_CHECK( handle.GetProperty<Matrix3>(index) == startValue );
+ Property::Index index = handle.RegisterProperty("testProperty", startValue);
+ DALI_TEST_CHECK(handle.GetProperty<Matrix3>(index) == startValue);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<Matrix3>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<Matrix3>(index) == startValue);
// Negative test i.e. there is no conversion from float to Matrix3
- handle.SetProperty( index, float(7.0) );
+ handle.SetProperty(index, float(7.0));
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( handle.GetProperty<Matrix3>(index) == startValue );
+ DALI_TEST_CHECK(handle.GetProperty<Matrix3>(index) == startValue);
// Positive test (sanity check)
- Matrix3 endValue(31,32,33,
- 21,22,23,
- 11,12,13);
- handle.SetProperty( index, endValue );
- DALI_TEST_CHECK( handle.GetProperty<Matrix3>(index) == endValue );
+ Matrix3 endValue(31, 32, 33, 21, 22, 23, 11, 12, 13);
+ handle.SetProperty(index, endValue);
+ DALI_TEST_CHECK(handle.GetProperty<Matrix3>(index) == endValue);
END_TEST;
}
TestApplication application;
Handle handle = WeightObject::New();
- DALI_TEST_CHECK( handle.GetProperty<float>(WeightObject::WEIGHT) == 0.0f );
+ DALI_TEST_CHECK(handle.GetProperty<float>(WeightObject::WEIGHT) == 0.0f);
// process the message so scene object is added to update manager
application.SendNotification();
// scope for the weight object
{
Handle handle = WeightObject::New();
- DALI_TEST_CHECK( handle.GetProperty<float>(WeightObject::WEIGHT) == 0.0f );
+ DALI_TEST_CHECK(handle.GetProperty<float>(WeightObject::WEIGHT) == 0.0f);
// process the message so scene object is added to update manager
application.SendNotification();
int UtcDaliHandleSetTypeInfo(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
Actor actor = Actor::DownCast(typeInfo.CreateInstance());
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
DevelHandle::SetTypeInfo(actor, typeInfo);
TypeInfo newTypeInfo;
- bool success = actor.GetTypeInfo( newTypeInfo );
- DALI_TEST_CHECK( success );
+ bool success = actor.GetTypeInfo(newTypeInfo);
+ DALI_TEST_CHECK(success);
DALI_TEST_CHECK(typeInfo.GetName() == newTypeInfo.GetName());
DALI_TEST_CHECK(typeInfo.GetBaseName() == newTypeInfo.GetBaseName());
{
TestApplication application;
- tet_infoline( "Create a custom property and set the value ensuring it can be retrieved synchronously" );
+ tet_infoline("Create a custom property and set the value ensuring it can be retrieved synchronously");
Actor actor = Actor::New();
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
- tet_infoline( "Create the custom property with an initial value" );
- float startValue(1.0f);
- Property::Index index = actor.RegisterProperty( "testProperty", startValue );
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), startValue, TEST_LOCATION );
+ tet_infoline("Create the custom property with an initial value");
+ float startValue(1.0f);
+ Property::Index index = actor.RegisterProperty("testProperty", startValue);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), startValue, TEST_LOCATION);
- tet_infoline( "Set the value, retrieve it and ensure both the synchronous and the async version work" );
- actor.SetProperty( index, 5.0f );
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), startValue, TEST_LOCATION );
+ tet_infoline("Set the value, retrieve it and ensure both the synchronous and the async version work");
+ actor.SetProperty(index, 5.0f);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), startValue, TEST_LOCATION);
- tet_infoline( "Render and retrieve values again" );
+ tet_infoline("Render and retrieve values again");
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 5.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 5.0f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Create a custom property and retrieve its type" );
+ tet_infoline("Create a custom property and retrieve its type");
- Handle handle = Handle::New();
- Property::Index index = handle.RegisterProperty( "testProperty", 1.0f );
- DALI_TEST_EQUALS( handle.GetPropertyType( index ), Property::FLOAT, TEST_LOCATION );
+ Handle handle = Handle::New();
+ Property::Index index = handle.RegisterProperty("testProperty", 1.0f);
+ DALI_TEST_EQUALS(handle.GetPropertyType(index), Property::FLOAT, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Create a custom property and retrieve whether it's animatable etc." );
+ tet_infoline("Create a custom property and retrieve whether it's animatable etc.");
- Handle handle = Handle::New();
- Property::Index index = handle.RegisterProperty( "testProperty", 1.0f );
- DALI_TEST_EQUALS( handle.IsPropertyAnimatable( index ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.IsPropertyWritable( index ), true, TEST_LOCATION );
+ Handle handle = Handle::New();
+ Property::Index index = handle.RegisterProperty("testProperty", 1.0f);
+ DALI_TEST_EQUALS(handle.IsPropertyAnimatable(index), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.IsPropertyWritable(index), true, TEST_LOCATION);
- index = handle.RegisterProperty( "testProperty2", 1.0f, Property::READ_ONLY );
- DALI_TEST_EQUALS( handle.IsPropertyAnimatable( index ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.IsPropertyWritable( index ), false, TEST_LOCATION );
+ index = handle.RegisterProperty("testProperty2", 1.0f, Property::READ_ONLY);
+ DALI_TEST_EQUALS(handle.IsPropertyAnimatable(index), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.IsPropertyWritable(index), false, TEST_LOCATION);
- index = handle.RegisterProperty( "testProperty3", 1.0f, Property::READ_WRITE );
- DALI_TEST_EQUALS( handle.IsPropertyAnimatable( index ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.IsPropertyWritable( index ), true, TEST_LOCATION );
+ index = handle.RegisterProperty("testProperty3", 1.0f, Property::READ_WRITE);
+ DALI_TEST_EQUALS(handle.IsPropertyAnimatable(index), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.IsPropertyWritable(index), true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Get a default and non-animatable custom property using the GetCurrentProperty API" );
+ tet_infoline("Get a default and non-animatable custom property using the GetCurrentProperty API");
Actor actor = Actor::New();
- application.GetScene().Add( actor );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), true, TEST_LOCATION );
+ application.GetScene().Add(actor);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE), true, TEST_LOCATION);
- Property::Index index = actor.RegisterProperty( "testProperty3", 1.0f, Property::READ_WRITE );
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 1.0f, TEST_LOCATION );
+ Property::Index index = actor.RegisterProperty("testProperty3", 1.0f, Property::READ_WRITE);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 1.0f, TEST_LOCATION);
- actor.SetProperty( index, 2.0f );
- DALI_TEST_EQUALS( actor.GetProperty< float >( index ), 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetCurrentProperty< float >( index ), 2.0f, TEST_LOCATION );
+ actor.SetProperty(index, 2.0f);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(index), 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<float>(index), 2.0f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Needs type registry
- tet_infoline( "Test if a registered custom property exists on object" );
+ tet_infoline("Test if a registered custom property exists on object");
- Actor actor = Actor::New();
- auto propertyIndex = actor.RegisterProperty("customProperty1", 1.0f);
+ Actor actor = Actor::New();
+ auto propertyIndex = actor.RegisterProperty("customProperty1", 1.0f);
- DALI_TEST_EQUALS( actor.DoesCustomPropertyExist( propertyIndex ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.DoesCustomPropertyExist(propertyIndex), true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Needs type registry
- tet_infoline( "Test if a registered custom property does not exist on object" );
+ tet_infoline("Test if a registered custom property does not exist on object");
- Actor actor = Actor::New();
- auto propertyIndex = actor.RegisterProperty("customProperty1", 1.0f);
+ Actor actor = Actor::New();
+ auto propertyIndex = actor.RegisterProperty("customProperty1", 1.0f);
- DALI_TEST_EQUALS( actor.DoesCustomPropertyExist( propertyIndex+1 ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.DoesCustomPropertyExist(propertyIndex + 1), false, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Needs type registry
- tet_infoline( "Test that a default property does not show as a custom property on object" );
+ tet_infoline("Test that a default property does not show as a custom property on object");
Actor actor = Actor::New();
- DALI_TEST_EQUALS( actor.DoesCustomPropertyExist( Actor::Property::POSITION ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.DoesCustomPropertyExist(Actor::Property::POSITION), false, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Needs type registry
- tet_infoline( "Test that a child property does not exist on actor after parenting to container" );
+ tet_infoline("Test that a child property does not exist on actor after parenting to container");
TypeRegistry typeRegistry = TypeRegistry::Get();
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(Test::TestCustomActor) );
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(Test::TestCustomActor));
- const Property::Index CHILD_PROPERTY( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const char* CHILD_PROPERTY_NAME( "childProperty" );
+ const Property::Index CHILD_PROPERTY(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const char* CHILD_PROPERTY_NAME("childProperty");
- ChildPropertyRegistration( customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER );
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER);
auto container = Test::TestCustomActor::New();
- application.GetScene().Add( container );
+ application.GetScene().Add(container);
auto child = Actor::New();
- container.Add( child ); // Resolve child properties (if any)
+ container.Add(child); // Resolve child properties (if any)
- DALI_TEST_EQUALS( child.DoesCustomPropertyExist( CHILD_PROPERTY ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.DoesCustomPropertyExist(CHILD_PROPERTY), false, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Needs type registry
- tet_infoline( "Test that a child property exists after being set" );
+ tet_infoline("Test that a child property exists after being set");
TypeRegistry typeRegistry = TypeRegistry::Get();
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(Test::TestCustomActor) );
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(Test::TestCustomActor));
- const Property::Index CHILD_PROPERTY( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const char* CHILD_PROPERTY_NAME( "childProperty" );
+ const Property::Index CHILD_PROPERTY(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const char* CHILD_PROPERTY_NAME("childProperty");
- ChildPropertyRegistration( customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER );
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER);
auto container = Test::TestCustomActor::New();
- application.GetScene().Add( container );
+ application.GetScene().Add(container);
auto child = Actor::New();
- container.Add( child ); // Resolve child properties (if any)
- child.SetProperty( CHILD_PROPERTY, 2 );
+ container.Add(child); // Resolve child properties (if any)
+ child.SetProperty(CHILD_PROPERTY, 2);
- DALI_TEST_EQUALS( child.DoesCustomPropertyExist( CHILD_PROPERTY ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetProperty<int>( CHILD_PROPERTY ), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.DoesCustomPropertyExist(CHILD_PROPERTY), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetProperty<int>(CHILD_PROPERTY), 2, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Needs type registry
- tet_infoline( "Test that a child property is re-indexed after registration, and that it exists" );
+ tet_infoline("Test that a child property is re-indexed after registration, and that it exists");
TypeRegistry typeRegistry = TypeRegistry::Get();
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(Test::TestCustomActor) );
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(Test::TestCustomActor));
- const Property::Index CHILD_PROPERTY( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const char* CHILD_PROPERTY_NAME( "childProperty" );
+ const Property::Index CHILD_PROPERTY(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const char* CHILD_PROPERTY_NAME("childProperty");
- ChildPropertyRegistration( customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER );
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER);
auto container = Test::TestCustomActor::New();
- application.GetScene().Add( container );
+ application.GetScene().Add(container);
auto child = Actor::New();
- child.RegisterProperty( CHILD_PROPERTY_NAME, Property::Value(3) );
- container.Add( child ); // Resolve child properties (if any)
+ child.RegisterProperty(CHILD_PROPERTY_NAME, Property::Value(3));
+ container.Add(child); // Resolve child properties (if any)
- DALI_TEST_EQUALS( child.DoesCustomPropertyExist( CHILD_PROPERTY ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetProperty<int>( CHILD_PROPERTY ), 3, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.DoesCustomPropertyExist(CHILD_PROPERTY), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetProperty<int>(CHILD_PROPERTY), 3, TEST_LOCATION);
END_TEST;
}
namespace
{
-
struct PropertySetSignalCheck
{
PropertySetSignalCheck(bool& signalReceived, Property::Value& value)
void operator()(Handle& handle, Property::Index index, Property::Value value)
{
mSignalReceived = true;
- mValue = value;
+ mValue = value;
}
void Reset()
void CheckSignalReceived()
{
- if (!mSignalReceived)
+ if(!mSignalReceived)
{
tet_printf("Expected Property Set signal was not received\n");
tet_result(TET_FAIL);
}
}
- bool& mSignalReceived; // owned by individual tests
+ bool& mSignalReceived; // owned by individual tests
Property::Value& mValue;
};
-} // anon namespace
+} // namespace
int UtcDaliHandlePropertySetSignal01(void)
{
TestApplication application;
- bool signalReceived(false);
- Property::Value value;
+ bool signalReceived(false);
+ Property::Value value;
PropertySetSignalCheck propertySetCheck(signalReceived, value);
- tet_infoline( "Test that setting a default property triggers a signal" );
+ tet_infoline("Test that setting a default property triggers a signal");
auto actor = Actor::New();
actor.PropertySetSignal().Connect(&application, propertySetCheck);
- actor.SetProperty( Actor::Property::POSITION, Vector3::XAXIS );
+ actor.SetProperty(Actor::Property::POSITION, Vector3::XAXIS);
propertySetCheck.CheckSignalReceived();
END_TEST;
}
-
int UtcDaliHandlePropertySetSignal02(void)
{
TestApplication application;
- bool signalReceived(false);
- Property::Value value;
+ bool signalReceived(false);
+ Property::Value value;
PropertySetSignalCheck propertySetCheck(signalReceived, value);
- tet_infoline( "Test that setting a custom property triggers a signal" );
+ tet_infoline("Test that setting a custom property triggers a signal");
auto actor = Actor::New();
actor.PropertySetSignal().Connect(&application, propertySetCheck);
auto propertyIndex = actor.RegisterProperty("propName", 3.0f);
- actor.SetProperty( propertyIndex, 5.0f );
+ actor.SetProperty(propertyIndex, 5.0f);
propertySetCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( propertySetCheck.mValue, Property::Value( 5.0f ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(propertySetCheck.mValue, Property::Value(5.0f), 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliHandlePropertySetSignal03(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- bool signalReceived(false);
- Property::Value value;
+ bool signalReceived(false);
+ Property::Value value;
PropertySetSignalCheck propertySetCheck(signalReceived, value);
- tet_infoline( "Test that setting a child property triggers a signal" );
+ tet_infoline("Test that setting a child property triggers a signal");
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(Test::TestCustomActor) );
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(Test::TestCustomActor));
- const Property::Index CHILD_PROPERTY( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const char* CHILD_PROPERTY_NAME( "childProperty" );
+ const Property::Index CHILD_PROPERTY(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const char* CHILD_PROPERTY_NAME("childProperty");
- ChildPropertyRegistration( customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER );
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), CHILD_PROPERTY_NAME, CHILD_PROPERTY, Property::INTEGER);
auto container = Test::TestCustomActor::New();
- application.GetScene().Add( container );
+ application.GetScene().Add(container);
auto child = Actor::New();
- child.RegisterProperty( CHILD_PROPERTY_NAME, Property::Value(3) );
+ child.RegisterProperty(CHILD_PROPERTY_NAME, Property::Value(3));
child.PropertySetSignal().Connect(&application, propertySetCheck);
- container.Add( child ); // Resolve child properties (if any)
+ container.Add(child); // Resolve child properties (if any)
- DALI_TEST_EQUALS( child.DoesCustomPropertyExist( CHILD_PROPERTY ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( child.GetProperty<int>( CHILD_PROPERTY ), 3, TEST_LOCATION );
+ DALI_TEST_EQUALS(child.DoesCustomPropertyExist(CHILD_PROPERTY), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(child.GetProperty<int>(CHILD_PROPERTY), 3, TEST_LOCATION);
- child.SetProperty( CHILD_PROPERTY, 29 );
+ child.SetProperty(CHILD_PROPERTY, 29);
propertySetCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( propertySetCheck.mValue, Property::Value( 29 ), TEST_LOCATION );
+ DALI_TEST_EQUALS(propertySetCheck.mValue, Property::Value(29), TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliHandlePropertySetSignal04(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- bool signalReceived(false);
- Property::Value value;
+ bool signalReceived(false);
+ Property::Value value;
PropertySetSignalCheck propertySetCheck(signalReceived, value);
- tet_infoline( "Test that setting a property on a vanilla Object triggers a signal" );
+ tet_infoline("Test that setting a property on a vanilla Object triggers a signal");
constexpr Property::Index TEST_PROPERTY_KEY_INDEX = 1;
- const std::string TEST_PROPERTY_KEY_NAME = "testProperty";
+ const std::string TEST_PROPERTY_KEY_NAME = "testProperty";
Handle vanillaObject = Handle::New();
- auto propertyIndex = vanillaObject.RegisterProperty(
+ auto propertyIndex = vanillaObject.RegisterProperty(
TEST_PROPERTY_KEY_INDEX,
TEST_PROPERTY_KEY_NAME,
- Color::WHITE );
+ Color::WHITE);
vanillaObject.PropertySetSignal().Connect(&application, propertySetCheck);
- DALI_TEST_EQUALS( vanillaObject.DoesCustomPropertyExist( propertyIndex ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( vanillaObject.GetProperty<Vector4>( propertyIndex ), Color::WHITE, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(vanillaObject.DoesCustomPropertyExist(propertyIndex), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(vanillaObject.GetProperty<Vector4>(propertyIndex), Color::WHITE, 0.001f, TEST_LOCATION);
vanillaObject[TEST_PROPERTY_KEY_NAME] = Color::RED;
propertySetCheck.CheckSignalReceived();
- DALI_TEST_EQUALS( propertySetCheck.mValue, Property::Value( Color::RED ), 0.001f, TEST_LOCATION );
- DALI_TEST_VALUE_EQUALS( vanillaObject[propertyIndex], Property::Value( Color::RED), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(propertySetCheck.mValue, Property::Value(Color::RED), 0.001f, TEST_LOCATION);
+ DALI_TEST_VALUE_EQUALS(vanillaObject[propertyIndex], Property::Value(Color::RED), 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliHandlePropertySetProperties(void)
{
TestApplication application;
- const Vector3 actorSize( 10.0f, 20.0f, 30.0f );
- const Vector3 anchorPoint( 1.0f, 0.5f, 0.0f );
- const Vector4 color( 0.1f, 0.2, 0.3f, 0.4f );
+ const Vector3 actorSize(10.0f, 20.0f, 30.0f);
+ const Vector3 anchorPoint(1.0f, 0.5f, 0.0f);
+ const Vector4 color(0.1f, 0.2, 0.3f, 0.4f);
Handle handle = Actor::New();
handle.SetProperties(
- Property::Map
- {
- { Actor::Property::SIZE, actorSize },
- { Actor::Property::ANCHOR_POINT, anchorPoint },
- { "color", color },
- { "invalid", Vector2::ZERO } // It should quietly ignore invalid data
- }
- );
- DALI_TEST_EQUALS( handle.GetProperty( Actor::Property::SIZE ).Get< Vector3 >(), actorSize, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty( Actor::Property::ANCHOR_POINT ).Get< Vector3 >(), anchorPoint, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty( Actor::Property::COLOR ).Get< Vector4 >(), color, TEST_LOCATION );
+ Property::Map{
+ {Actor::Property::SIZE, actorSize},
+ {Actor::Property::ANCHOR_POINT, anchorPoint},
+ {"color", color},
+ {"invalid", Vector2::ZERO} // It should quietly ignore invalid data
+ });
+ DALI_TEST_EQUALS(handle.GetProperty(Actor::Property::SIZE).Get<Vector3>(), actorSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty(Actor::Property::ANCHOR_POINT).Get<Vector3>(), anchorPoint, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty(Actor::Property::COLOR).Get<Vector4>(), color, TEST_LOCATION);
END_TEST;
}
int UtcDaliHandleTemplateNew01(void)
{
TestApplication application;
- const Vector3 actorSize( 10.0f, 20.0f, 30.0f );
- const Vector3 anchorPoint( 1.0f, 0.5f, 0.0f );
- const Vector4 color( 0.1f, 0.2, 0.3f, 0.4f );
+ const Vector3 actorSize(10.0f, 20.0f, 30.0f);
+ const Vector3 anchorPoint(1.0f, 0.5f, 0.0f);
+ const Vector4 color(0.1f, 0.2, 0.3f, 0.4f);
- Handle handle = Handle::New< Actor >(
- Property::Map
- {
- { Actor::Property::SIZE, actorSize },
- { Actor::Property::ANCHOR_POINT, anchorPoint },
- { "color", color },
- { "invalid", Vector2::ZERO } // It should quietly ignore invalid data
- }
- );
+ Handle handle = Handle::New<Actor>(
+ Property::Map{
+ {Actor::Property::SIZE, actorSize},
+ {Actor::Property::ANCHOR_POINT, anchorPoint},
+ {"color", color},
+ {"invalid", Vector2::ZERO} // It should quietly ignore invalid data
+ });
- DALI_TEST_EQUALS( handle.GetProperty( Actor::Property::SIZE ).Get< Vector3 >(), actorSize, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty( Actor::Property::ANCHOR_POINT ).Get< Vector3 >(), anchorPoint, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty( Actor::Property::COLOR ).Get< Vector4 >(), color, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetProperty(Actor::Property::SIZE).Get<Vector3>(), actorSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty(Actor::Property::ANCHOR_POINT).Get<Vector3>(), anchorPoint, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty(Actor::Property::COLOR).Get<Vector4>(), color, TEST_LOCATION);
END_TEST;
}
Handle handle = Actor::New();
handle.SetProperties(
- Property::Map
- {
- { Actor::Property::SIZE, Vector3( 400.0f, 200.0f, 100.0f ) },
- { Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER },
- { Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER },
- { Actor::Property::NAME, "Actor" },
- { Actor::Property::LEAVE_REQUIRED, true },
- { "color", Color::RED },
- }
- );
+ Property::Map{
+ {Actor::Property::SIZE, Vector3(400.0f, 200.0f, 100.0f)},
+ {Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_CENTER},
+ {Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_CENTER},
+ {Actor::Property::NAME, "Actor"},
+ {Actor::Property::LEAVE_REQUIRED, true},
+ {"color", Color::RED},
+ });
Property::Map map;
- handle.GetProperties( map );
+ handle.GetProperties(map);
// Get all the properties and ensure they match
- DALI_TEST_EQUALS( handle.GetPropertyCount(), map.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetPropertyCount(), map.Count(), TEST_LOCATION);
- for( auto position = 0u; position < map.Count(); ++position )
+ for(auto position = 0u; position < map.Count(); ++position)
{
- auto keyValuePair = map.GetKeyValue( position );
- const auto& index = keyValuePair.first.indexKey;
- const auto& value = keyValuePair.second;
- auto handleValue = handle.GetProperty( index );
+ auto keyValuePair = map.GetKeyValue(position);
+ const auto& index = keyValuePair.first.indexKey;
+ const auto& value = keyValuePair.second;
+ auto handleValue = handle.GetProperty(index);
- switch( value.GetType() )
+ switch(value.GetType())
{
- case Property::NONE: break;
- case Property::BOOLEAN: DALI_TEST_EQUALS( value.Get< bool >(), handleValue.Get< bool >(), TEST_LOCATION ); break;
- case Property::FLOAT: DALI_TEST_EQUALS( value.Get< float >(), handleValue.Get< float >(), TEST_LOCATION ); break;
- case Property::INTEGER: DALI_TEST_EQUALS( value.Get< int >(), handleValue.Get< int >(), TEST_LOCATION ); break;
- case Property::VECTOR2: DALI_TEST_EQUALS( value.Get< Vector2 >(), handleValue.Get< Vector2 >(), TEST_LOCATION ); break;
- case Property::VECTOR3: DALI_TEST_EQUALS( value.Get< Vector3 >(), handleValue.Get< Vector3 >(), TEST_LOCATION ); break;
- case Property::VECTOR4: DALI_TEST_EQUALS( value.Get< Vector4 >(), handleValue.Get< Vector4 >(), TEST_LOCATION ); break;
- case Property::MATRIX3: DALI_TEST_EQUALS( value.Get< Matrix3 >(), handleValue.Get< Matrix3 >(), TEST_LOCATION ); break;
- case Property::MATRIX: DALI_TEST_EQUALS( value.Get< Matrix >(), handleValue.Get< Matrix >(), TEST_LOCATION ); break;
- case Property::RECTANGLE: DALI_TEST_EQUALS( value.Get< Rect< int > >(), handleValue.Get< Rect< int > >(), TEST_LOCATION ); break;
- case Property::ROTATION: DALI_TEST_EQUALS( value.Get< Quaternion >(), handleValue.Get< Quaternion >(), TEST_LOCATION ); break;
- case Property::STRING: DALI_TEST_EQUALS( value.Get< std::string >(), handleValue.Get< std::string >(), TEST_LOCATION ); break;
- case Property::ARRAY: DALI_TEST_EQUALS( value.GetArray()->Count(), handleValue.GetArray()->Count(), TEST_LOCATION ); break;
- case Property::MAP: DALI_TEST_EQUALS( value.GetMap()->Count(), handleValue.GetMap()->Count(), TEST_LOCATION ); break;
- case Property::EXTENTS: DALI_TEST_EQUALS( value.Get< Extents >(), handleValue.Get< Extents >(), TEST_LOCATION ); break;
+ case Property::NONE:
+ break;
+ case Property::BOOLEAN:
+ DALI_TEST_EQUALS(value.Get<bool>(), handleValue.Get<bool>(), TEST_LOCATION);
+ break;
+ case Property::FLOAT:
+ DALI_TEST_EQUALS(value.Get<float>(), handleValue.Get<float>(), TEST_LOCATION);
+ break;
+ case Property::INTEGER:
+ DALI_TEST_EQUALS(value.Get<int>(), handleValue.Get<int>(), TEST_LOCATION);
+ break;
+ case Property::VECTOR2:
+ DALI_TEST_EQUALS(value.Get<Vector2>(), handleValue.Get<Vector2>(), TEST_LOCATION);
+ break;
+ case Property::VECTOR3:
+ DALI_TEST_EQUALS(value.Get<Vector3>(), handleValue.Get<Vector3>(), TEST_LOCATION);
+ break;
+ case Property::VECTOR4:
+ DALI_TEST_EQUALS(value.Get<Vector4>(), handleValue.Get<Vector4>(), TEST_LOCATION);
+ break;
+ case Property::MATRIX3:
+ DALI_TEST_EQUALS(value.Get<Matrix3>(), handleValue.Get<Matrix3>(), TEST_LOCATION);
+ break;
+ case Property::MATRIX:
+ DALI_TEST_EQUALS(value.Get<Matrix>(), handleValue.Get<Matrix>(), TEST_LOCATION);
+ break;
+ case Property::RECTANGLE:
+ DALI_TEST_EQUALS(value.Get<Rect<int> >(), handleValue.Get<Rect<int> >(), TEST_LOCATION);
+ break;
+ case Property::ROTATION:
+ DALI_TEST_EQUALS(value.Get<Quaternion>(), handleValue.Get<Quaternion>(), TEST_LOCATION);
+ break;
+ case Property::STRING:
+ DALI_TEST_EQUALS(value.Get<std::string>(), handleValue.Get<std::string>(), TEST_LOCATION);
+ break;
+ case Property::ARRAY:
+ DALI_TEST_EQUALS(value.GetArray()->Count(), handleValue.GetArray()->Count(), TEST_LOCATION);
+ break;
+ case Property::MAP:
+ DALI_TEST_EQUALS(value.GetMap()->Count(), handleValue.GetMap()->Count(), TEST_LOCATION);
+ break;
+ case Property::EXTENTS:
+ DALI_TEST_EQUALS(value.Get<Extents>(), handleValue.Get<Extents>(), TEST_LOCATION);
+ break;
}
}
// Add a custom property and ensure the count goes up by one.
const auto countBefore = map.Count();
- handle.RegisterProperty( "tempProperty", Color::GREEN );
- handle.GetProperties( map );
- DALI_TEST_EQUALS( countBefore + 1, map.Count(), TEST_LOCATION );
+ handle.RegisterProperty("tempProperty", Color::GREEN);
+ handle.GetProperties(map);
+ DALI_TEST_EQUALS(countBefore + 1, map.Count(), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliHandleSetPropertyNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
- int arg1(0);
+ int arg1(0);
Dali::Property::Value arg2;
- instance.SetProperty(arg1,arg2);
+ instance.SetProperty(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliHandleRegisterPropertyNegative01(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
- std::string arg1;
+ std::string arg1;
Dali::Property::Value arg2;
- instance.RegisterProperty(arg1,arg2);
+ instance.RegisterProperty(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliHandleRegisterPropertyNegative02(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
- std::string arg1;
- Dali::Property::Value arg2;
+ std::string arg1;
+ Dali::Property::Value arg2;
Dali::Property::AccessMode arg3(Property::READ_ONLY);
- instance.RegisterProperty(arg1,arg2,arg3);
+ instance.RegisterProperty(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliHandleRemoveConstraintsNegative01(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
unsigned int arg1(0u);
int UtcDaliHandleRemoveConstraintsNegative02(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
instance.RemoveConstraints();
int UtcDaliHandleAddPropertyNotificationNegative01(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
- int arg1(0);
- int arg2(0);
+ int arg1(0);
+ int arg2(0);
Dali::PropertyCondition arg3;
- instance.AddPropertyNotification(arg1,arg2,arg3);
+ instance.AddPropertyNotification(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliHandleAddPropertyNotificationNegative02(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
- int arg1(0);
+ int arg1(0);
Dali::PropertyCondition arg2;
- instance.AddPropertyNotification(arg1,arg2);
+ instance.AddPropertyNotification(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliHandleRemovePropertyNotificationNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
Dali::PropertyNotification arg1;
int UtcDaliHandleRemovePropertyNotificationsNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
instance.RemovePropertyNotifications();
int UtcDaliHandleGetPropertyNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleGetPropertyNameNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleGetPropertyTypeNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleGetPropertyCountNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
instance.GetPropertyCount();
int UtcDaliHandleGetPropertyIndexNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
std::string arg1;
int UtcDaliHandleGetCurrentPropertyNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleGetPropertyIndicesNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
Dali::Vector<int> arg1;
int UtcDaliHandleIsPropertyWritableNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleIsPropertyAnimatableNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleIsPropertyAConstraintInputNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
int arg1(0);
int UtcDaliHandleSupportsNegative(void)
{
TestApplication application;
- Dali::Handle instance;
+ Dali::Handle instance;
try
{
Dali::Handle::Capability arg1(Handle::DYNAMIC_PROPERTIES);
END_TEST;
}
-
int UtcDaliHandleIndexOperatorByIndexP01(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
- actor[Actor::Property::SIZE] = Vector3( 100.0f, 200.0f, 1.0f );
+ actor[Actor::Property::SIZE] = Vector3(100.0f, 200.0f, 1.0f);
- DALI_TEST_EQUALS( actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3( 100.0f, 200.0f, 1.0f ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetProperty<Vector3>(Actor::Property::SIZE), Vector3(100.0f, 200.0f, 1.0f), 0.001f, TEST_LOCATION);
+ actor.SetProperty(Actor::Property::POSITION, Vector3(10.0f, 20.0f, 0.0f));
- actor.SetProperty( Actor::Property::POSITION, Vector3( 10.0f, 20.0f, 0.0f ) );
-
- Vector3 position = actor[ Actor::Property::POSITION ];
- DALI_TEST_EQUALS( position, Vector3( 10.0f, 20.0f, 0.0f ), TEST_LOCATION );
+ Vector3 position = actor[Actor::Property::POSITION];
+ DALI_TEST_EQUALS(position, Vector3(10.0f, 20.0f, 0.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliHandleIndexOperatorByIndexP02(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
const Vector4 defaultActorColor(1.0f, 1.0f, 1.0f, 1.0f);
actor.SetProperty(Actor::Property::COLOR, defaultActorColor);
actor[Actor::Property::COLOR_RED] = 0.5f;
- DALI_TEST_EQUALS( actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.001f, TEST_LOCATION);
- DALI_TEST_EQUALS( actor.GetProperty<Vector4>(Actor::Property::COLOR), Vector4(0.5f, 1.0f, 1.0f, 1.0f), 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<float>(Actor::Property::COLOR_RED), 0.5f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty<Vector4>(Actor::Property::COLOR), Vector4(0.5f, 1.0f, 1.0f, 1.0f), 0.001f, TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION, Vector3( 10.0f, 20.0f, 0.0f ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(10.0f, 20.0f, 0.0f));
- DALI_TEST_EQUALS( (float)actor[ Actor::Property::POSITION_Z ], 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS((float)actor[Actor::Property::POSITION_Z], 0.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliHandleIndexOperatorByIndexP03(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
const Vector4 defaultActorColor(1.0f, 1.0f, 1.0f, 1.0f);
actor.SetProperty(Actor::Property::COLOR, defaultActorColor);
// Value under test is second to allow compiler to deduce type
- DALI_TEST_VALUE_EQUALS( actor[Actor::Property::COLOR_RED], 1.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_VALUE_EQUALS(actor[Actor::Property::COLOR_RED], 1.0f, 0.001f, TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION, Vector3( 10.0f, 20.0f, 0.0f ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(10.0f, 20.0f, 0.0f));
- DALI_TEST_EQUALS( (float)actor[ Actor::Property::POSITION_Z ], 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS((float)actor[Actor::Property::POSITION_Z], 0.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliHandleIndexOperatorByNameP01(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
- actor["size"] = Vector3( 100.0f, 200.0f, 1.0f );
+ actor["size"] = Vector3(100.0f, 200.0f, 1.0f);
- DALI_TEST_VALUE_EQUALS( actor.GetProperty(Actor::Property::SIZE), Vector3( 100.0f, 200.0f, 1.0f ), 0.001f, TEST_LOCATION );
+ DALI_TEST_VALUE_EQUALS(actor.GetProperty(Actor::Property::SIZE), Vector3(100.0f, 200.0f, 1.0f), 0.001f, TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION, Vector3( 10.0f, 20.0f, 0.0f ) );
- Vector3 position = actor[ "position" ];
+ actor.SetProperty(Actor::Property::POSITION, Vector3(10.0f, 20.0f, 0.0f));
+ Vector3 position = actor["position"];
- DALI_TEST_EQUALS( position, Vector3( 10.0f, 20.0f, 0.0f ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(position, Vector3(10.0f, 20.0f, 0.0f), 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliHandleIndexOperatorByNameP02(void)
{
TestApplication application;
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
const Vector4 defaultActorColor(1.0f, 1.0f, 1.0f, 1.0f);
actor.SetProperty(Actor::Property::COLOR, defaultActorColor);
actor["colorRed"] = 0.5f;
- DALI_TEST_VALUE_EQUALS( actor.GetProperty(Actor::Property::COLOR_RED), 0.5f, 0.001f, TEST_LOCATION);
- DALI_TEST_VALUE_EQUALS( actor.GetProperty(Actor::Property::COLOR), Vector4(0.5f, 1.0f, 1.0f, 1.0f), 0.001f, TEST_LOCATION);
+ DALI_TEST_VALUE_EQUALS(actor.GetProperty(Actor::Property::COLOR_RED), 0.5f, 0.001f, TEST_LOCATION);
+ DALI_TEST_VALUE_EQUALS(actor.GetProperty(Actor::Property::COLOR), Vector4(0.5f, 1.0f, 1.0f, 1.0f), 0.001f, TEST_LOCATION);
- actor.SetProperty( Actor::Property::POSITION, Vector3( 10.0f, 20.0f, 0.0f ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(10.0f, 20.0f, 0.0f));
- float positionY = actor[ "positionY" ];
- DALI_TEST_EQUALS( positionY, 20.0f, 0.001f, TEST_LOCATION );
+ float positionY = actor["positionY"];
+ DALI_TEST_EQUALS(positionY, 20.0f, 0.001f, TEST_LOCATION);
// Should automatically promote IndirectValue to Property::Value rvalue.
- DALI_TEST_VALUE_EQUALS( actor["positionZ"], 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_VALUE_EQUALS(actor["positionZ"], 0.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliHandleIndexOperatorNegative02(void)
{
TestApplication application;
try
{
Vector3 position = actor[Actor::Property::POSITION];
- if( position == position )
+ if(position == position)
{
DALI_TEST_CHECK(false); // Should throw before reaching here.
}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <string>
-#include <stdlib.h>
-#include <dali/devel-api/common/hash.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/common/hash.h>
+#include <stdlib.h>
+
+#include <string>
void utc_dali_hash_startup(void)
{
test_return_value = TET_PASS;
}
-
int UtcDaliHash(void)
{
// To fully test the Hash distribution we need to use a tool like http://code.google.com/p/smhasher/
tet_infoline("UtcDaliHash");
- const std::string testString1( "highp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
- const std::string testString2( "lowp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
+ const std::string testString1("highp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
+ const std::string testString2("lowp vec4 glowColor = vec4( uGlowColor.rgb, uGlowColor.a * clampedColor.a );");
- DALI_TEST_CHECK( Dali::CalculateHash( testString1 ) != Dali::CalculateHash( testString2 ) );
- DALI_TEST_CHECK( Dali::CalculateHash( testString1, testString2 ) != Dali::CalculateHash( testString2, testString1 ) );
+ DALI_TEST_CHECK(Dali::CalculateHash(testString1) != Dali::CalculateHash(testString2));
+ DALI_TEST_CHECK(Dali::CalculateHash(testString1, testString2) != Dali::CalculateHash(testString2, testString1));
END_TEST;
}
// negative test, check hash value == initial value
const std::string emptyString;
- DALI_TEST_CHECK( Dali::CalculateHash( emptyString ) != 0 );
- DALI_TEST_CHECK( Dali::CalculateHash( emptyString, emptyString ) != 0 );
+ DALI_TEST_CHECK(Dali::CalculateHash(emptyString) != 0);
+ DALI_TEST_CHECK(Dali::CalculateHash(emptyString, emptyString) != 0);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/devel-api/events/hit-test-algorithm.h>
#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
/**
* The functor to be used in the hit-test algorithm to check whether the actor is hittable.
*/
{
bool hittable = false;
- switch (type)
+ switch(type)
{
case Dali::HitTestAlgorithm::CHECK_ACTOR:
{
// Check whether the actor is visible and not fully transparent.
- if( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE )
- && actor.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ).a > 0.01f) // not FULLY_TRANSPARENT
+ if(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) && actor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR).a > 0.01f) // not FULLY_TRANSPARENT
{
// Check whether the actor has the specific name "HittableActor"
- if(actor.GetProperty< std::string >( Actor::Property::NAME ) == "HittableActor")
+ if(actor.GetProperty<std::string>(Actor::Property::NAME) == "HittableActor")
{
hittable = true;
}
}
case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
{
- if( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) ) // Actor is visible, if not visible then none of its children are visible.
+ if(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE)) // Actor is visible, if not visible then none of its children are visible.
{
hittable = true;
}
return hittable;
};
-
bool DefaultIsActorTouchableFunction(Dali::Actor actor, Dali::HitTestAlgorithm::TraverseType type)
{
bool hittable = false;
- switch (type)
+ switch(type)
{
case Dali::HitTestAlgorithm::CHECK_ACTOR:
{
- if( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) &&
- actor.GetProperty< bool >( Actor::Property::SENSITIVE ) &&
- actor.GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR ).a > 0.01f)
+ if(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) &&
+ actor.GetProperty<bool>(Actor::Property::SENSITIVE) &&
+ actor.GetCurrentProperty<Vector4>(Actor::Property::WORLD_COLOR).a > 0.01f)
{
hittable = true;
}
}
case Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE:
{
- if( actor.GetCurrentProperty< bool >( Actor::Property::VISIBLE ) && // Actor is visible, if not visible then none of its children are visible.
- actor.GetProperty< bool >( Actor::Property::SENSITIVE )) // Actor is sensitive, if insensitive none of its children should be hittable either.
+ if(actor.GetCurrentProperty<bool>(Actor::Property::VISIBLE) && // Actor is visible, if not visible then none of its children are visible.
+ actor.GetProperty<bool>(Actor::Property::SENSITIVE)) // Actor is sensitive, if insensitive none of its children should be hittable either.
{
hittable = true;
}
} // anonymous namespace
-
// Positive test case for a method
int UtcDaliHitTestAlgorithmWithFunctor(void)
{
Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor.SetProperty( Actor::Property::NAME,"NonHittableActor");
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::NAME, "NonHittableActor");
stage.Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 localCoordinates;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Perform a hit-test at the given screen coordinates
Dali::HitTestAlgorithm::Results results;
- Dali::HitTestAlgorithm::HitTest( stage, screenCoordinates, results, IsActorHittableFunction );
- DALI_TEST_CHECK( results.actor != actor );
+ Dali::HitTestAlgorithm::HitTest(stage, screenCoordinates, results, IsActorHittableFunction);
+ DALI_TEST_CHECK(results.actor != actor);
- actor.SetProperty( Actor::Property::NAME,"HittableActor");
+ actor.SetProperty(Actor::Property::NAME, "HittableActor");
- results.actor = Actor();
+ results.actor = Actor();
results.actorCoordinates = Vector2::ZERO;
// Perform a hit-test at the given screen coordinates
- Dali::HitTestAlgorithm::HitTest( stage, screenCoordinates, results, IsActorHittableFunction );
- DALI_TEST_CHECK( results.actor == actor );
- DALI_TEST_EQUALS( localCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION );
+ Dali::HitTestAlgorithm::HitTest(stage, screenCoordinates, results, IsActorHittableFunction);
+ DALI_TEST_CHECK(results.actor == actor);
+ DALI_TEST_EQUALS(localCoordinates, results.actorCoordinates, 0.1f, TEST_LOCATION);
END_TEST;
}
TestApplication application;
tet_infoline("Testing Dali::HitTestAlgorithm with parallel Ortho camera()");
- Stage stage = Stage::GetCurrent();
- RenderTaskList renderTaskList = stage.GetRenderTaskList();
- RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
- Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
+ Stage stage = Stage::GetCurrent();
+ RenderTaskList renderTaskList = stage.GetRenderTaskList();
+ RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
+ Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
- Vector2 stageSize ( stage.GetSize() );
- cameraActor.SetOrthographicProjection( stageSize );
- cameraActor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 1600.0f));
+ Vector2 stageSize(stage.GetSize());
+ cameraActor.SetOrthographicProjection(stageSize);
+ cameraActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 1600.0f));
- Vector2 actorSize( stageSize * 0.5f );
+ Vector2 actorSize(stageSize * 0.5f);
// Create two actors with half the size of the stage and set them to be partially overlapping
Actor blue = Actor::New();
- blue.SetProperty( Actor::Property::NAME, "Blue" );
- blue.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- blue.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(1.0f/3.0f, 1.0f/3.0f, 0.5f) );
- blue.SetProperty( Actor::Property::SIZE, actorSize );
- blue.SetProperty( Actor::Property::POSITION_Z, 30.0f);
-
- Actor green = Actor::New( );
- green.SetProperty( Actor::Property::NAME, "Green" );
- green.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- green.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(2.0f/3.0f, 2.0f/3.0f, 0.5f) );
- green.SetProperty( Actor::Property::SIZE, actorSize );
+ blue.SetProperty(Actor::Property::NAME, "Blue");
+ blue.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ blue.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(1.0f / 3.0f, 1.0f / 3.0f, 0.5f));
+ blue.SetProperty(Actor::Property::SIZE, actorSize);
+ blue.SetProperty(Actor::Property::POSITION_Z, 30.0f);
+
+ Actor green = Actor::New();
+ green.SetProperty(Actor::Property::NAME, "Green");
+ green.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ green.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(2.0f / 3.0f, 2.0f / 3.0f, 0.5f));
+ green.SetProperty(Actor::Property::SIZE, actorSize);
// Add the actors to the view
- stage.Add( blue );
- stage.Add( green );
+ stage.Add(blue);
+ stage.Add(green);
// Render and notify
application.SendNotification();
HitTestAlgorithm::Results results;
HitTest(stage, stageSize / 2.0f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == green );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 1.0f/6.0f, TEST_LOCATION );
+ DALI_TEST_CHECK(results.actor == green);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 1.0f / 6.0f, TEST_LOCATION);
HitTest(stage, stageSize / 3.0f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == blue );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
+ DALI_TEST_CHECK(results.actor == blue);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION);
HitTest(stage, stageSize * 2.0f / 3.0f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == green );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
+ DALI_TEST_CHECK(results.actor == green);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliHitTestAlgorithmOrtho02(void)
{
TestApplication application;
tet_infoline("Testing Dali::HitTestAlgorithm with offset Ortho camera()");
- Stage stage = Stage::GetCurrent();
- RenderTaskList renderTaskList = stage.GetRenderTaskList();
- RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
- Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
+ Stage stage = Stage::GetCurrent();
+ RenderTaskList renderTaskList = stage.GetRenderTaskList();
+ RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
+ Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
- Vector2 stageSize ( stage.GetSize() );
- cameraActor.SetOrthographicProjection(-stageSize.x * 0.3f, stageSize.x * 0.7f,
- stageSize.y * 0.3f, -stageSize.y * 0.7f,
- 800.0f, 4895.0f);
- cameraActor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 1600.0f));
+ Vector2 stageSize(stage.GetSize());
+ cameraActor.SetOrthographicProjection(-stageSize.x * 0.3f, stageSize.x * 0.7f, stageSize.y * 0.3f, -stageSize.y * 0.7f, 800.0f, 4895.0f);
+ cameraActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 1600.0f));
- Vector2 actorSize( stageSize * 0.5f );
+ Vector2 actorSize(stageSize * 0.5f);
// Create two actors with half the size of the stage and set them to be partially overlapping
Actor blue = Actor::New();
- blue.SetProperty( Actor::Property::NAME, "Blue" );
- blue.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- blue.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0.2f, 0.2f, 0.5f) );
- blue.SetProperty( Actor::Property::SIZE, actorSize );
- blue.SetProperty( Actor::Property::POSITION_Z, 30.0f);
-
- Actor green = Actor::New( );
- green.SetProperty( Actor::Property::NAME, "Green" );
- green.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- green.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0.4f, 0.4f, 0.5f) );
- green.SetProperty( Actor::Property::SIZE, actorSize );
+ blue.SetProperty(Actor::Property::NAME, "Blue");
+ blue.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ blue.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.2f, 0.2f, 0.5f));
+ blue.SetProperty(Actor::Property::SIZE, actorSize);
+ blue.SetProperty(Actor::Property::POSITION_Z, 30.0f);
+
+ Actor green = Actor::New();
+ green.SetProperty(Actor::Property::NAME, "Green");
+ green.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ green.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.4f, 0.4f, 0.5f));
+ green.SetProperty(Actor::Property::SIZE, actorSize);
// Add the actors to the view
- stage.Add( blue );
- stage.Add( green );
+ stage.Add(blue);
+ stage.Add(green);
// Render and notify
application.SendNotification();
{
HitTestAlgorithm::Results results;
- HitTest(stage, Vector2( 240.0f, 400.0f ), results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == green );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.6f, 0.01f, TEST_LOCATION );
+ HitTest(stage, Vector2(240.0f, 400.0f), results, &DefaultIsActorTouchableFunction);
+ DALI_TEST_CHECK(results.actor == green);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 0.6f, 0.01f, TEST_LOCATION);
}
{
HitTestAlgorithm::Results results;
- HitTest(stage, Vector2( 0.001f, 0.001f ), results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == blue );
- DALI_TEST_EQUALS( results.actorCoordinates, Vector2( 0.001f, 0.001f ), 0.001f, TEST_LOCATION );
+ HitTest(stage, Vector2(0.001f, 0.001f), results, &DefaultIsActorTouchableFunction);
+ DALI_TEST_CHECK(results.actor == blue);
+ DALI_TEST_EQUALS(results.actorCoordinates, Vector2(0.001f, 0.001f), 0.001f, TEST_LOCATION);
}
{
HitTestAlgorithm::Results results;
HitTest(stage, stageSize, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( ! results.actor );
- DALI_TEST_EQUALS( results.actorCoordinates, Vector2::ZERO, TEST_LOCATION );
+ DALI_TEST_CHECK(!results.actor);
+ DALI_TEST_EQUALS(results.actorCoordinates, Vector2::ZERO, TEST_LOCATION);
}
// Just inside green
{
HitTestAlgorithm::Results results;
- HitTest(stage, stageSize*0.69f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == green );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.98f, 0.01f, TEST_LOCATION );
+ HitTest(stage, stageSize * 0.69f, results, &DefaultIsActorTouchableFunction);
+ DALI_TEST_CHECK(results.actor == green);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 0.98f, 0.01f, TEST_LOCATION);
}
END_TEST;
TestApplication application;
tet_infoline("Testing Dali::HitTestAlgorithm with a stencil");
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
Actor rootLayer = stage.GetRootLayer();
- rootLayer.SetProperty( Actor::Property::NAME, "RootLayer" );
+ rootLayer.SetProperty(Actor::Property::NAME, "RootLayer");
// Create a layer
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- layer.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- layer.SetProperty( Actor::Property::NAME, "layer" );
- stage.Add( layer );
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ layer.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ layer.SetProperty(Actor::Property::NAME, "layer");
+ stage.Add(layer);
// Create a clipping actor and add it to the layer.
Actor clippingActor = CreateRenderableActor();
- clippingActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- clippingActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- clippingActor.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
- clippingActor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- clippingActor.SetProperty( Actor::Property::NAME, "clippingActor" );
- layer.Add( clippingActor );
+ clippingActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ clippingActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ clippingActor.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
+ clippingActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ clippingActor.SetProperty(Actor::Property::NAME, "clippingActor");
+ layer.Add(clippingActor);
// Create a renderable actor and add it to the clipping actor.
Actor childActor = CreateRenderableActor();
- childActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- childActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- childActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- childActor.SetProperty( Actor::Property::NAME, "childActor" );
- clippingActor.Add( childActor );
+ childActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ childActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ childActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ childActor.SetProperty(Actor::Property::NAME, "childActor");
+ clippingActor.Add(childActor);
// Render and notify
application.SendNotification();
// Hit within clippingActor and childActor.
HitTestAlgorithm::Results results;
- HitTest( stage, Vector2( 10.0f, 10.0f ), results, &DefaultIsActorTouchableFunction );
- DALI_TEST_CHECK( results.actor == childActor );
- tet_printf( "Hit: %s\n", ( results.actor ? results.actor.GetProperty< std::string >( Actor::Property::NAME ).c_str() : "NULL" ) );
+ HitTest(stage, Vector2(10.0f, 10.0f), results, &DefaultIsActorTouchableFunction);
+ DALI_TEST_CHECK(results.actor == childActor);
+ tet_printf("Hit: %s\n", (results.actor ? results.actor.GetProperty<std::string>(Actor::Property::NAME).c_str() : "NULL"));
// Hit within childActor but outside of clippingActor, should hit the root-layer instead.
- HitTest( stage, Vector2( 60.0f, 60.0f ), results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == rootLayer );
- tet_printf( "Hit: %s\n", ( results.actor ? results.actor.GetProperty< std::string >( Actor::Property::NAME ).c_str() : "NULL" ) );
+ HitTest(stage, Vector2(60.0f, 60.0f), results, &DefaultIsActorTouchableFunction);
+ DALI_TEST_CHECK(results.actor == rootLayer);
+ tet_printf("Hit: %s\n", (results.actor ? results.actor.GetProperty<std::string>(Actor::Property::NAME).c_str() : "NULL"));
END_TEST;
}
TestApplication application;
tet_infoline("Testing Dali::HitTestAlgorithm with overlay actors");
- Stage stage = Stage::GetCurrent();
- RenderTaskList renderTaskList = stage.GetRenderTaskList();
- RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
- Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
+ Stage stage = Stage::GetCurrent();
+ RenderTaskList renderTaskList = stage.GetRenderTaskList();
+ RenderTask defaultRenderTask = renderTaskList.GetTask(0u);
+ Dali::CameraActor cameraActor = defaultRenderTask.GetCameraActor();
- Vector2 stageSize ( stage.GetSize() );
- cameraActor.SetOrthographicProjection( stageSize );
- cameraActor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 1600.0f));
+ Vector2 stageSize(stage.GetSize());
+ cameraActor.SetOrthographicProjection(stageSize);
+ cameraActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 1600.0f));
- Vector2 actorSize( stageSize * 0.5f );
+ Vector2 actorSize(stageSize * 0.5f);
// Create two actors with half the size of the stage and set them to be partially overlapping
Actor blue = Actor::New();
- blue.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
- blue.SetProperty( Actor::Property::NAME, "Blue" );
- blue.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- blue.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(1.0f/3.0f, 1.0f/3.0f, 0.5f) );
- blue.SetProperty( Actor::Property::SIZE, actorSize );
- blue.SetProperty( Actor::Property::POSITION_Z, 30.0f);
-
- Actor green = Actor::New( );
- green.SetProperty( Actor::Property::NAME, "Green" );
- green.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- green.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(2.0f/3.0f, 2.0f/3.0f, 0.5f) );
- green.SetProperty( Actor::Property::SIZE, actorSize );
+ blue.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
+ blue.SetProperty(Actor::Property::NAME, "Blue");
+ blue.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ blue.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(1.0f / 3.0f, 1.0f / 3.0f, 0.5f));
+ blue.SetProperty(Actor::Property::SIZE, actorSize);
+ blue.SetProperty(Actor::Property::POSITION_Z, 30.0f);
+
+ Actor green = Actor::New();
+ green.SetProperty(Actor::Property::NAME, "Green");
+ green.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ green.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(2.0f / 3.0f, 2.0f / 3.0f, 0.5f));
+ green.SetProperty(Actor::Property::SIZE, actorSize);
// Add the actors to the view
- stage.Add( blue );
- stage.Add( green );
+ stage.Add(blue);
+ stage.Add(green);
// Render and notify
application.SendNotification();
//Hit in the intersection. Should pick the blue actor since it is an overlay.
HitTest(stage, stageSize / 2.0f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == blue );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 5.0f/6.0f, TEST_LOCATION );
+ DALI_TEST_CHECK(results.actor == blue);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 5.0f / 6.0f, TEST_LOCATION);
//Hit in the blue actor
HitTest(stage, stageSize / 3.0f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == blue );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
+ DALI_TEST_CHECK(results.actor == blue);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION);
//Hit in the green actor
HitTest(stage, stageSize * 2.0f / 3.0f, results, &DefaultIsActorTouchableFunction);
- DALI_TEST_CHECK( results.actor == green );
- DALI_TEST_EQUALS( results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION );
+ DALI_TEST_CHECK(results.actor == green);
+ DALI_TEST_EQUALS(results.actorCoordinates, actorSize * 0.5f, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/hover-event-devel.h>
#include <dali/integration-api/events/hover-event-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali/devel-api/events/hover-event-devel.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
SignalData()
- : functorCalled( false ),
+ : functorCalled(false),
hoverEvent(),
hoveredActor()
{
hoveredActor.Reset();
}
- bool functorCalled;
+ bool functorCalled;
HoverEvent hoverEvent;
- Actor hoveredActor;
+ Actor hoveredActor;
};
// Functor that sets the data when called
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- HoverEventFunctor( SignalData& data, bool returnValue = true )
- : signalData( data ),
- returnValue( returnValue )
+ HoverEventFunctor(SignalData& data, bool returnValue = true)
+ : signalData(data),
+ returnValue(returnValue)
{
}
- bool operator()( Actor actor, const HoverEvent& hoverEvent )
+ bool operator()(Actor actor, const HoverEvent& hoverEvent)
{
signalData.functorCalled = true;
- signalData.hoveredActor = actor;
- signalData.hoverEvent = hoverEvent;
+ signalData.hoveredActor = actor;
+ signalData.hoverEvent = hoverEvent;
return returnValue;
}
SignalData& signalData;
- bool returnValue;
+ bool returnValue;
};
// Functor that removes the actor when called.
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- RemoveActorFunctor( SignalData& data, bool returnValue = true )
- : HoverEventFunctor( data, returnValue )
+ RemoveActorFunctor(SignalData& data, bool returnValue = true)
+ : HoverEventFunctor(data, returnValue)
{
}
- bool operator()( Actor actor, const HoverEvent& hoverEvent )
+ bool operator()(Actor actor, const HoverEvent& hoverEvent)
{
- Actor parent( actor.GetParent() );
- if ( parent )
+ Actor parent(actor.GetParent());
+ if(parent)
{
- parent.Remove( actor );
+ parent.Remove(actor);
}
- return HoverEventFunctor::operator()( actor, hoverEvent );
+ return HoverEventFunctor::operator()(actor, hoverEvent);
}
};
-Integration::HoverEvent GenerateSingleHover( PointState::Type state, const Vector2& screenPosition )
+Integration::HoverEvent GenerateSingleHover(PointState::Type state, const Vector2& screenPosition)
{
Integration::HoverEvent hoverEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- hoverEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ hoverEvent.points.push_back(point);
return hoverEvent;
}
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 localCoordinates;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, data.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( 0, data.hoverEvent.GetDeviceId( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, data.hoverEvent.GetTime(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor, data.hoverEvent.GetHitActor( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, data.hoverEvent.GetDeviceId( 1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, data.hoverEvent.GetState( 1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.hoverEvent.GetScreenPosition( 1 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.hoverEvent.GetLocalPosition( 1 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( Dali::Actor(), data.hoverEvent.GetHitActor( 1 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, data.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(0, data.hoverEvent.GetDeviceId(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, data.hoverEvent.GetTime(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor, data.hoverEvent.GetHitActor(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, data.hoverEvent.GetDeviceId(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, data.hoverEvent.GetState(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.hoverEvent.GetScreenPosition(1), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.hoverEvent.GetLocalPosition(1), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Dali::Actor(), data.hoverEvent.GetHitActor(1), TEST_LOCATION);
data.Reset();
// Emit a motion signal
screenCoordinates.x = screenCoordinates.y = 11.0f;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, data.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( 0, data.hoverEvent.GetDeviceId( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, data.hoverEvent.GetTime(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor, data.hoverEvent.GetHitActor( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, data.hoverEvent.GetDeviceId( 1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, data.hoverEvent.GetState( 1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.hoverEvent.GetScreenPosition( 1 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.hoverEvent.GetLocalPosition( 1 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( Dali::Actor(), data.hoverEvent.GetHitActor( 1 ), TEST_LOCATION );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, data.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(0, data.hoverEvent.GetDeviceId(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, data.hoverEvent.GetTime(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor, data.hoverEvent.GetHitActor(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, data.hoverEvent.GetDeviceId(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, data.hoverEvent.GetState(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.hoverEvent.GetScreenPosition(1), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.hoverEvent.GetLocalPosition(1), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Dali::Actor(), data.hoverEvent.GetHitActor(1), TEST_LOCATION);
data.Reset();
// Emit a finished signal
screenCoordinates.x = screenCoordinates.y = 12.0f;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleHover( PointState::FINISHED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, data.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( 0, data.hoverEvent.GetDeviceId( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, data.hoverEvent.GetTime(), TEST_LOCATION );
- DALI_TEST_EQUALS( actor, data.hoverEvent.GetHitActor( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( -1, data.hoverEvent.GetDeviceId( 1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, data.hoverEvent.GetState( 1 ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.hoverEvent.GetScreenPosition( 1 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.hoverEvent.GetLocalPosition( 1 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( Dali::Actor(), data.hoverEvent.GetHitActor( 1 ), TEST_LOCATION );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleHover(PointState::FINISHED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, data.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(0, data.hoverEvent.GetDeviceId(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, data.hoverEvent.GetTime(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actor, data.hoverEvent.GetHitActor(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, data.hoverEvent.GetDeviceId(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, data.hoverEvent.GetState(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.hoverEvent.GetScreenPosition(1), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.hoverEvent.GetLocalPosition(1), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Dali::Actor(), data.hoverEvent.GetHitActor(1), TEST_LOCATION);
data.Reset();
// Emit a started signal where the actor is not present
screenCoordinates.x = screenCoordinates.y = 200.0f;
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( !data.hoverEvent );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(!data.hoverEvent);
END_TEST;
}
{
TestApplication application;
- Integration::Scene stage = application.GetScene();
- Vector2 stageSize = stage.GetSize();
+ Integration::Scene stage = application.GetScene();
+ Vector2 stageSize = stage.GetSize();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
stage.Add(actor);
// Render and notify
application.Render();
// Get the camera's near and far planes
- RenderTaskList taskList = stage.GetRenderTaskList();
- Dali::RenderTask task = taskList.GetTask(0);
- CameraActor camera = task.GetCameraActor();
- float nearPlane = camera.GetNearClippingPlane();
- float farPlane = camera.GetFarClippingPlane();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ Dali::RenderTask task = taskList.GetTask(0);
+ CameraActor camera = task.GetCameraActor();
+ float nearPlane = camera.GetNearClippingPlane();
+ float farPlane = camera.GetFarClippingPlane();
// Calculate the current distance of the actor from the camera
float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
- float distance = (stageSize.y * 0.5f) / tanHalfFov;
+ float distance = (stageSize.y * 0.5f) / tanHalfFov;
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
- Vector2 screenCoordinates( stageSize.x * 0.5f, stageSize.y * 0.5f );
+ Vector2 screenCoordinates(stageSize.x * 0.5f, stageSize.y * 0.5f);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a started signal where actor is just at the camera's near plane
- actor.SetProperty( Actor::Property::POSITION_Z, distance - nearPlane);
+ actor.SetProperty(Actor::Property::POSITION_Z, distance - nearPlane);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a started signal where actor is closer than the camera's near plane
- actor.SetProperty( Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f);
+ actor.SetProperty(Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a started signal where actor is just at the camera's far plane
- actor.SetProperty( Actor::Property::POSITION_Z, distance - farPlane);
+ actor.SetProperty(Actor::Property::POSITION_Z, distance - farPlane);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a started signal where actor is further than the camera's far plane
- actor.SetProperty( Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f);
+ actor.SetProperty(Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
{
// Emit an empty HoverEvent
Integration::HoverEvent event;
- application.ProcessEvent( event );
- tet_result( TET_FAIL );
+ application.ProcessEvent(event);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_ASSERT( e, "!event.points.empty()", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "!event.points.empty()", TEST_LOCATION);
}
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
// Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not.
- application.ProcessEvent( GenerateSingleHover( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
// Emit another interrupted signal, our signal handler should not be called.
- application.ProcessEvent( GenerateSingleHover( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
int UtcDaliHoverParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data, false );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data, false);
+ actor.HoveredSignal().Connect(&application, functor);
// Connect to root actor's hovered signal
- SignalData rootData;
- HoverEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.HoveredSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ HoverEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.HoveredSignal().Connect(&application, rootFunctor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 actorCoordinates, rootCoordinates;
- actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorCoordinates, data.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit a motion signal
screenCoordinates.x = screenCoordinates.y = 11.0f;
- actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorCoordinates, data.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit a finished signal
screenCoordinates.x = screenCoordinates.y = 12.0f;
- actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleHover( PointState::FINISHED, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleHover(PointState::FINISHED, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorCoordinates, data.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit a started signal where the actor is not present, will hit the root actor though
screenCoordinates.x = screenCoordinates.y = 200.0f;
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.hoverEvent.GetScreenPosition( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.hoverEvent.GetLocalPosition( 0 ), 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.hoverEvent.GetHitActor( 0 ) );
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.hoverEvent.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.hoverEvent.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.hoverEvent.GetLocalPosition(0), 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.hoverEvent.GetHitActor(0));
END_TEST;
}
int UtcDaliHoverInterruptedParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data, false );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data, false);
+ actor.HoveredSignal().Connect(&application, functor);
// Connect to root actor's hovered signal
- SignalData rootData;
- HoverEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.HoveredSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ HoverEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.HoveredSignal().Connect(&application, rootFunctor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit an interrupted signal
- application.ProcessEvent( GenerateSingleHover( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit another started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
rootData.Reset();
// Remove actor from Stage
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
// Render and notify
application.SendNotification();
application.Render();
// Emit an interrupted signal, only root actor's signal should be called.
- application.ProcessEvent( GenerateSingleHover( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit another interrupted state, none of the signal's should be called.
- application.ProcessEvent( GenerateSingleHover( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, rootData.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, rootData.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Set actor to require leave events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
// Emit a motion signal outside of actor, should be signalled with a Leave
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
// Another motion outside of actor, no signalling
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 201.0f, 201.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(201.0f, 201.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Another motion event inside actor, signalled with motion
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
// We do not want to listen to leave events anymore
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, false );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
// Another motion event outside of actor, no signalling
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverLeaveParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data, false );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data, false);
+ actor.HoveredSignal().Connect(&application, functor);
// Connect to root actor's hovered signal
- SignalData rootData;
- HoverEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.HoveredSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ HoverEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.HoveredSignal().Connect(&application, rootFunctor);
// Set actor to require leave events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
- rootActor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
+ rootActor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Emit a motion signal outside of actor, should be signalled with a Leave
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Another motion outside of actor, only rootActor signalled
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 201.0f, 201.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(201.0f, 201.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Another motion event inside actor, signalled with motion
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// We do not want to listen to leave events of actor anymore
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, false );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
// Another motion event outside of root actor, only root signalled
- Vector2 stageSize( application.GetScene().GetSize() );
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( stageSize.width + 10.0f, stageSize.height + 10.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ Vector2 stageSize(application.GetScene().GetSize());
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(stageSize.width + 10.0f, stageSize.height + 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, rootData.hoverEvent.GetState(0), TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
// Change actor to insensitive
- actor.SetProperty( Actor::Property::SENSITIVE, false );
+ actor.SetProperty(Actor::Property::SENSITIVE, false);
// Emit a motion signal, signalled with an interrupted
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverActorBecomesInsensitiveParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data, false );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data, false);
+ actor.HoveredSignal().Connect(&application, functor);
// Connect to root actor's hovered signal
- SignalData rootData;
- HoverEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.HoveredSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ HoverEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.HoveredSignal().Connect(&application, rootFunctor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::STARTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoverEvent.GetHitActor( 0 ) );
- DALI_TEST_CHECK( actor == rootData.hoverEvent.GetHitActor( 0 ) );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, data.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::STARTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoverEvent.GetHitActor(0));
+ DALI_TEST_CHECK(actor == rootData.hoverEvent.GetHitActor(0));
data.Reset();
rootData.Reset();
// Remove actor from Stage
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
// Render and notify
application.SendNotification();
application.Render();
// Make root actor insensitive
- rootActor.SetProperty( Actor::Property::SENSITIVE, false );
+ rootActor.SetProperty(Actor::Property::SENSITIVE, false);
// Emit a motion signal, signalled with an interrupted (should get interrupted even if within root actor)
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.hoverEvent.GetState(0), TEST_LOCATION);
END_TEST;
}
int UtcDaliHoverMultipleLayers(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
+ SignalData data;
+ HoverEventFunctor functor(data);
- Layer layer1 ( Layer::New() );
- layer1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer1 );
+ Layer layer1(Layer::New());
+ layer1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer1);
- Actor actor1 ( Actor::New() );
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor1.SetProperty( Actor::Property::POSITION_Z, 1.0f ); // Should hit actor1 in this layer
- layer1.Add( actor1 );
+ Actor actor1(Actor::New());
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor1.SetProperty(Actor::Property::POSITION_Z, 1.0f); // Should hit actor1 in this layer
+ layer1.Add(actor1);
// Render and notify
application.SendNotification();
application.Render();
// Connect to layer1 and actor1
- layer1.HoveredSignal().Connect( &application, functor );
- actor1.HoveredSignal().Connect( &application, functor );
+ layer1.HoveredSignal().Connect(&application, functor);
+ actor1.HoveredSignal().Connect(&application, functor);
// Hit in hittable area, actor1 should be hit
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.hoveredActor == actor1 );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.hoveredActor == actor1);
data.Reset();
// Make layer1 insensitive, nothing should be hit
- layer1.SetProperty( Actor::Property::SENSITIVE, false );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ layer1.SetProperty(Actor::Property::SENSITIVE, false);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Make layer1 sensitive again, again actor1 will be hit
- layer1.SetProperty( Actor::Property::SENSITIVE, true );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.hoveredActor == actor1 );
+ layer1.SetProperty(Actor::Property::SENSITIVE, true);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.hoveredActor == actor1);
data.Reset();
// Make rootActor insensitive, nothing should be hit
- rootActor.SetProperty( Actor::Property::SENSITIVE, false );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ rootActor.SetProperty(Actor::Property::SENSITIVE, false);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Make rootActor sensitive
- rootActor.SetProperty( Actor::Property::SENSITIVE, true );
+ rootActor.SetProperty(Actor::Property::SENSITIVE, true);
// Add another layer
- Layer layer2 ( Layer::New() );
- layer2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- layer2.SetProperty( Actor::Property::POSITION_Z, 10.0f ); // Should hit layer2 in this layer rather than actor2
- application.GetScene().Add( layer2 );
+ Layer layer2(Layer::New());
+ layer2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ layer2.SetProperty(Actor::Property::POSITION_Z, 10.0f); // Should hit layer2 in this layer rather than actor2
+ application.GetScene().Add(layer2);
- Actor actor2 ( Actor::New() );
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- layer2.Add( actor2 );
+ Actor actor2(Actor::New());
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ layer2.Add(actor2);
// Render and notify
application.SendNotification();
application.Render();
// Connect to layer2 and actor2
- layer2.HoveredSignal().Connect( &application, functor );
- actor2.HoveredSignal().Connect( &application, functor );
+ layer2.HoveredSignal().Connect(&application, functor);
+ actor2.HoveredSignal().Connect(&application, functor);
// Emit an event, should hit layer2
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
//DALI_TEST_CHECK( data.hoveredActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
data.Reset();
// Make layer2 insensitive, should hit actor1
- layer2.SetProperty( Actor::Property::SENSITIVE, false );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.hoveredActor == actor1 );
+ layer2.SetProperty(Actor::Property::SENSITIVE, false);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.hoveredActor == actor1);
data.Reset();
// Make layer2 sensitive again, should hit layer2
- layer2.SetProperty( Actor::Property::SENSITIVE, true );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ layer2.SetProperty(Actor::Property::SENSITIVE, true);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
//DALI_TEST_CHECK( data.hoveredActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
data.Reset();
// Make layer2 invisible, render and notify
- layer2.SetProperty( Actor::Property::VISIBLE, false );
+ layer2.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render();
// Should hit actor1
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.hoveredActor == actor1 );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.hoveredActor == actor1);
data.Reset();
// Make rootActor invisible, render and notify
- rootActor.SetProperty( Actor::Property::VISIBLE, false );
+ rootActor.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render();
// Should not hit anything
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverMultipleRenderTasks(void)
{
- TestApplication application;
- Integration::Scene stage ( application.GetScene() );
- Vector2 stageSize ( stage.GetSize() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+ Vector2 stageSize(stage.GetSize());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
stage.Add(actor);
// Create render task
- Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f );
- RenderTask renderTask ( application.GetScene().GetRenderTaskList().CreateTask() );
- renderTask.SetViewport( viewport );
- renderTask.SetInputEnabled( true );
+ Viewport viewport(stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f);
+ RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask());
+ renderTask.SetViewport(viewport);
+ renderTask.SetInputEnabled(true);
// Render and notify
application.SendNotification();
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Ensure renderTask actor can be hit too.
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Disable input on renderTask, should not be hittable
- renderTask.SetInputEnabled( false );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ renderTask.SetInputEnabled(false);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverMultipleRenderTasksWithChildLayer(void)
{
- TestApplication application;
- Integration::Scene stage ( application.GetScene() );
- Vector2 stageSize ( stage.GetSize() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+ Vector2 stageSize(stage.GetSize());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
stage.Add(actor);
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
actor.Add(layer);
// Create render task
- Viewport viewport( stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f );
- RenderTask renderTask ( application.GetScene().GetRenderTaskList().CreateTask() );
- renderTask.SetViewport( viewport );
- renderTask.SetInputEnabled( true );
- renderTask.SetSourceActor( actor );
+ Viewport viewport(stageSize.width * 0.5f, stageSize.height * 0.5f, stageSize.width * 0.5f, stageSize.height * 0.5f);
+ RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask());
+ renderTask.SetViewport(viewport);
+ renderTask.SetInputEnabled(true);
+ renderTask.SetSourceActor(actor);
// Render and notify
application.SendNotification();
application.Render();
// Connect to layer's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
- layer.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
+ layer.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Ensure renderTask actor can be hit too.
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Disable input on renderTask, should not be hittable
- renderTask.SetInputEnabled( false );
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ renderTask.SetInputEnabled(false);
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverOffscreenRenderTasks(void)
{
- TestApplication application;
- Integration::Scene stage ( application.GetScene() );
- Vector2 stageSize ( stage.GetSize() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+ Vector2 stageSize(stage.GetSize());
// FrameBufferImage for offscreen RenderTask
- FrameBuffer frameBuffer = FrameBuffer::New( stageSize.width, stageSize.height );
+ FrameBuffer frameBuffer = FrameBuffer::New(stageSize.width, stageSize.height);
// Create a renderable actor to display the FrameBufferImage
Actor renderableActor = CreateRenderableActor(frameBuffer.GetColorTexture());
- renderableActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- renderableActor.SetProperty( Actor::Property::SIZE, Vector2( stageSize.x, stageSize.y ) );
- renderableActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
- stage.Add( renderableActor );
+ renderableActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ renderableActor.SetProperty(Actor::Property::SIZE, Vector2(stageSize.x, stageSize.y));
+ renderableActor.ScaleBy(Vector3(1.0f, -1.0f, 1.0f)); // FIXME
+ stage.Add(renderableActor);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- stage.Add( actor );
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE ); // Ensure framebuffer connects
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ stage.Add(actor);
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE); // Ensure framebuffer connects
- stage.GetRenderTaskList().GetTask( 0u ).SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+ stage.GetRenderTaskList().GetTask(0u).SetScreenToFrameBufferFunction(RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION);
// Create a RenderTask
RenderTask renderTask = stage.GetRenderTaskList().CreateTask();
- renderTask.SetSourceActor( actor );
+ renderTask.SetSourceActor(actor);
renderTask.SetFrameBuffer(frameBuffer);
- renderTask.SetInputEnabled( true );
+ renderTask.SetInputEnabled(true);
// Create another RenderTask
- RenderTask renderTask2( stage.GetRenderTaskList().CreateTask() );
- renderTask2.SetInputEnabled( true );
+ RenderTask renderTask2(stage.GetRenderTaskList().CreateTask());
+ renderTask2.SetInputEnabled(true);
// Render and notify
application.SendNotification();
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverMultipleRenderableActors(void)
{
- TestApplication application;
- Integration::Scene stage ( application.GetScene() );
- Vector2 stageSize ( stage.GetSize() );
+ TestApplication application;
+ Integration::Scene stage(application.GetScene());
+ Vector2 stageSize(stage.GetSize());
Actor parent = CreateRenderableActor();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
stage.Add(parent);
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(actor);
// Render and notify
application.Render();
// Connect to layer's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- parent.HoveredSignal().Connect( &application, functor );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ parent.HoveredSignal().Connect(&application, functor);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.hoveredActor );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.hoveredActor);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- RemoveActorFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ RemoveActorFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Register for leave events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Re-add, render and notify
application.Render();
// Emit another signal outside of actor's area, should not get anything as the scene has changed.
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(210.0f, 210.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Render and notify
application.Render();
// Emit another signal outside of actor's area, should not get anything as the scene has changed.
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(210.0f, 210.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Re-add actor back to stage, render and notify
application.Render();
// Emit another started event
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Completely delete the actor
actor.Reset();
// Emit event, should not crash and should not receive an event.
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(210.0f, 210.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data, false );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data, false);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started signal
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Remove actor from stage
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
// Render and notify
application.SendNotification();
application.Render();
// Emit a move at the same point, we should not be signalled.
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliHoverLeaveActorReadded(void)
{
- TestApplication application;
+ TestApplication application;
Integration::Scene stage = application.GetScene();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
stage.Add(actor);
// Set actor to receive hover-events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Render and notify
application.SendNotification();
application.Render();
// Connect to actor's hovered signal
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit a started and motion
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 11.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(11.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Remove actor from stage and add again
- stage.Remove( actor );
- stage.Add( actor );
+ stage.Remove(actor);
+ stage.Add(actor);
// Emit a motion within the actor's bounds
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 12.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(12.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a motion outside the actor's bounds
- application.ProcessEvent( GenerateSingleHover( PointState::MOTION, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.hoverEvent.GetState( 0 ), TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, data.hoverEvent.GetState(0), TEST_LOCATION);
data.Reset();
END_TEST;
int UtcDaliHoverClippingActor(void)
{
- TestApplication application;
+ TestApplication application;
Integration::Scene stage = application.GetScene();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- stage.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ stage.Add(actor);
Actor clippingActor = Actor::New();
- clippingActor.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
- clippingActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- clippingActor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- stage.Add( clippingActor );
+ clippingActor.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
+ clippingActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ clippingActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ stage.Add(clippingActor);
// Add a child to the clipped region.
Actor clippingChild = Actor::New();
- clippingChild.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
- clippingChild.SetProperty( Actor::Property::POSITION, Vector2( 25.0f, 25.0f ));
- clippingChild.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- clippingActor.Add( clippingChild );
+ clippingChild.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
+ clippingChild.SetProperty(Actor::Property::POSITION, Vector2(25.0f, 25.0f));
+ clippingChild.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ clippingActor.Add(clippingChild);
// Render and notify.
application.SendNotification();
application.Render();
// Connect to actor's hovered signal.
- SignalData data;
- HoverEventFunctor functor( data );
- actor.HoveredSignal().Connect( &application, functor );
+ SignalData data;
+ HoverEventFunctor functor(data);
+ actor.HoveredSignal().Connect(&application, functor);
// Emit an event within clipped area - no hit.
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit an event outside the clipped area but within the actor area, we should have a hit.
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 60.0f, 60.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(60.0f, 60.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- clippingChild.HoveredSignal().Connect( &application, functor );
+ clippingChild.HoveredSignal().Connect(&application, functor);
// Emit an event inside part of the child which is within the clipped area, we should have a hit.
- application.ProcessEvent( GenerateSingleHover( PointState::STARTED, Vector2( 30.0f, 30.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleHover(PointState::STARTED, Vector2(30.0f, 30.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
{
TestApplication application;
- Dali::HoverEvent hoverEvent = DevelHoverEvent::New( 100 );
- DALI_TEST_CHECK( hoverEvent );
+ Dali::HoverEvent hoverEvent = DevelHoverEvent::New(100);
+ DALI_TEST_CHECK(hoverEvent);
// Emit a started signal
- DALI_TEST_EQUALS( 100, hoverEvent.GetTime(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, hoverEvent.GetPointCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(100, hoverEvent.GetTime(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, hoverEvent.GetPointCount(), TEST_LOCATION);
END_TEST;
}
-
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
using namespace Dali;
namespace
{
-
const int REPEAT = 1000;
-size_t g_creationCount = 0;
-size_t g_destructionCount = 0;
-size_t g_creationCountSubclass = 0;
-size_t g_destructionCountSubclass = 0;
-size_t g_creationCountUnrelated = 0;
+size_t g_creationCount = 0;
+size_t g_destructionCount = 0;
+size_t g_creationCountSubclass = 0;
+size_t g_destructionCountSubclass = 0;
+size_t g_creationCountUnrelated = 0;
size_t g_destructionCountUnrelated = 0;
class Counted : public RefObject
TestObject& Assign(const TestObject& testObject)
{
RefObject::operator=(testObject);
- data = testObject.data;
+ data = testObject.data;
return *this;
}
int data;
};
-
} // Anonymous namespace
/**
*/
int UtcDaliIntrusivePtrIntrusivePtr(void)
{
- tet_infoline( "Testing Dali::IntrusivePtr::IntrusivePtr()" );
+ tet_infoline("Testing Dali::IntrusivePtr::IntrusivePtr()");
g_creationCount = g_destructionCount = 0;
IntrusivePtr<Counted> counted;
- DALI_TEST_EQUALS( g_creationCount, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
// Test the pointer is null
- DALI_TEST_EQUALS( counted.Get(), (Counted*) 0, TEST_LOCATION );
- DALI_TEST_EQUALS( &(*counted), (Counted*) 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted.Get(), (Counted*)0, TEST_LOCATION);
+ DALI_TEST_EQUALS(&(*counted), (Counted*)0, TEST_LOCATION);
// Check destruction of the null smart pointer does nothing:
counted = IntrusivePtr<Counted>();
- DALI_TEST_EQUALS( g_creationCount, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrIntrusivePtrTP(void)
{
- tet_infoline( "Testing Dali::IntrusivePtr::IntrusivePtr(T*)" );
+ tet_infoline("Testing Dali::IntrusivePtr::IntrusivePtr(T*)");
g_creationCount = g_destructionCount = 0;
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
counted = 0;
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 1u, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrIntrusivePtrIntrusivePtrUP(void)
{
- tet_infoline( "Testing Dali::IntrusivePtr::IntrusivePtr(IntrusivePtr<U> const &)" );
+ tet_infoline("Testing Dali::IntrusivePtr::IntrusivePtr(IntrusivePtr<U> const &)");
g_creationCount = g_destructionCount = g_creationCountSubclass = g_destructionCountSubclass = 0;
- IntrusivePtr<CountedSubclass> countedSubclass( new CountedSubclass );
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_creationCountSubclass, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCountSubclass, 0u, TEST_LOCATION );
+ IntrusivePtr<CountedSubclass> countedSubclass(new CountedSubclass);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_creationCountSubclass, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCountSubclass, 0u, TEST_LOCATION);
- IntrusivePtr<Counted> counted( countedSubclass );
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(countedSubclass);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2, TEST_LOCATION);
// Make loads more references:
- std::vector< IntrusivePtr<Counted> > intrusivePtrs;
- for( int i = 0; i < REPEAT; ++i )
+ std::vector<IntrusivePtr<Counted> > intrusivePtrs;
+ for(int i = 0; i < REPEAT; ++i)
{
- intrusivePtrs.push_back( IntrusivePtr<Counted>( countedSubclass ) );
+ intrusivePtrs.push_back(IntrusivePtr<Counted>(countedSubclass));
}
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2 + REPEAT, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2 + REPEAT, TEST_LOCATION);
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_creationCountSubclass, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_creationCountSubclass, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrIntrusivePtrIntrusivePtrP(void)
{
- tet_infoline( "Testing Dali::IntrusivePtr::IntrusivePtr(IntrusivePtr const &)" );
+ tet_infoline("Testing Dali::IntrusivePtr::IntrusivePtr(IntrusivePtr const &)");
// Pass a pointer to a constructed second object:
// Pass a pointer to null:
g_creationCount = g_destructionCount = 0;
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( counted->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 1, TEST_LOCATION);
- IntrusivePtr<Counted> counted2( counted );
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2, TEST_LOCATION );
- DALI_TEST_EQUALS( counted.Get(), counted2.Get(), TEST_LOCATION );
+ IntrusivePtr<Counted> counted2(counted);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted.Get(), counted2.Get(), TEST_LOCATION);
// Make loads more references:
- std::vector< IntrusivePtr<Counted> > intrusivePtrs;
- for( int i = 0; i < REPEAT; ++i )
+ std::vector<IntrusivePtr<Counted> > intrusivePtrs;
+ for(int i = 0; i < REPEAT; ++i)
{
- intrusivePtrs.push_back( IntrusivePtr<Counted>( counted ) );
+ intrusivePtrs.push_back(IntrusivePtr<Counted>(counted));
}
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2 + REPEAT, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2 + REPEAT, TEST_LOCATION);
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
intrusivePtrs.clear();
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2, TEST_LOCATION);
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
counted.Reset();
- DALI_TEST_EQUALS( counted2->ReferenceCount(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted2->ReferenceCount(), 1, TEST_LOCATION);
counted2.Reset();
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 1u, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrGetP(void)
{
- tet_infoline( "Testing Dali::IntrusivePtr::Get()" );
+ tet_infoline("Testing Dali::IntrusivePtr::Get()");
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_CHECK( counted.Get() != 0 );
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( counted->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_CHECK(counted.Get() != 0);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrGetN(void)
{
- tet_infoline( "Testing Dali::IntrusivePtr::Get()" );
+ tet_infoline("Testing Dali::IntrusivePtr::Get()");
g_creationCount = 0;
- IntrusivePtr<Counted> counted( 0 );
- DALI_TEST_CHECK( counted.Get() == 0 );
- DALI_TEST_EQUALS( g_creationCount, 0u, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(0);
+ DALI_TEST_CHECK(counted.Get() == 0);
+ DALI_TEST_EQUALS(g_creationCount, 0u, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrArrowOperatorP(void)
{
- tet_infoline( "Positive Test for Dali::IntrusivePtr::operator->()" );
+ tet_infoline("Positive Test for Dali::IntrusivePtr::operator->()");
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_CHECK( (counted.operator->()) != 0 );
- DALI_TEST_EQUALS( counted->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_CHECK((counted.operator->()) != 0);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrArrowOperatorN(void)
{
- tet_infoline( "Negative Test for Dali::IntrusivePtr::operator->()" );
+ tet_infoline("Negative Test for Dali::IntrusivePtr::operator->()");
IntrusivePtr<Counted> counted;
- DALI_TEST_CHECK( (counted.operator->()) == 0 );
+ DALI_TEST_CHECK((counted.operator->()) == 0);
END_TEST;
}
int UtcDaliIntrusivePtrIndirectionOperatorP(void)
{
- tet_infoline( "Positive Test for Dali::IntrusivePtr::operator*()" );
+ tet_infoline("Positive Test for Dali::IntrusivePtr::operator*()");
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_CHECK( &(counted.operator*()) != 0 );
- DALI_TEST_EQUALS( (*counted).ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_CHECK(&(counted.operator*()) != 0);
+ DALI_TEST_EQUALS((*counted).ReferenceCount(), 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrIndirectionOperatorN(void)
{
- tet_infoline( "Negative Test for Dali::IntrusivePtr::operator*()" );
+ tet_infoline("Negative Test for Dali::IntrusivePtr::operator*()");
IntrusivePtr<Counted> counted;
- DALI_TEST_CHECK( &(counted.operator*()) == 0 );
+ DALI_TEST_CHECK(&(counted.operator*()) == 0);
END_TEST;
}
int UtcDaliIntrusivePtrResetP(void)
{
- tet_infoline( "Positive Test for Dali::IntrusivePtr::Reset()" );
+ tet_infoline("Positive Test for Dali::IntrusivePtr::Reset()");
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_CHECK( counted.Get() != 0 );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_CHECK(counted.Get() != 0);
counted.Reset();
- DALI_TEST_CHECK( counted.Get() == 0 );
+ DALI_TEST_CHECK(counted.Get() == 0);
END_TEST;
}
int UtcDaliIntrusivePtrResetN(void)
{
- tet_infoline( "Negative Test for Dali::IntrusivePtr::Reset()" );
+ tet_infoline("Negative Test for Dali::IntrusivePtr::Reset()");
IntrusivePtr<Counted> counted;
- Counted* firstGet = counted.Get();
+ Counted* firstGet = counted.Get();
counted.Reset();
- DALI_TEST_EQUALS( counted.Get(), firstGet, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted.Get(), firstGet, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrResetTP(void)
{
- tet_infoline( "Positive Test for Dali::IntrusivePtr::Reset(T*)" );
+ tet_infoline("Positive Test for Dali::IntrusivePtr::Reset(T*)");
g_creationCount = g_destructionCount = 0;
- IntrusivePtr<Counted> counted( new Counted );
+ IntrusivePtr<Counted> counted(new Counted);
- IntrusivePtr<Counted> counted2( new Counted );
+ IntrusivePtr<Counted> counted2(new Counted);
- DALI_TEST_EQUALS( counted->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( counted2->ReferenceCount(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted2->ReferenceCount(), 1, TEST_LOCATION);
- counted.Reset( counted2.Get() );
+ counted.Reset(counted2.Get());
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2, TEST_LOCATION );
- DALI_TEST_EQUALS( counted2->ReferenceCount(), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted2->ReferenceCount(), 2, TEST_LOCATION);
- DALI_TEST_EQUALS( counted.Get(), counted2.Get(), TEST_LOCATION );
+ DALI_TEST_EQUALS(counted.Get(), counted2.Get(), TEST_LOCATION);
- DALI_TEST_EQUALS( g_creationCount, 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_creationCount, 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 1u, TEST_LOCATION);
- counted2.Reset( (Counted*) 0 );
- counted.Reset( counted2.Get() );
- DALI_TEST_EQUALS( g_destructionCount, 2u, TEST_LOCATION );
+ counted2.Reset((Counted*)0);
+ counted.Reset(counted2.Get());
+ DALI_TEST_EQUALS(g_destructionCount, 2u, TEST_LOCATION);
// Check that reseting nulls is harmless:
- counted2.Reset( counted.Get() );
- counted.Reset( counted2.Get() );
+ counted2.Reset(counted.Get());
+ counted.Reset(counted2.Get());
- DALI_TEST_EQUALS( g_destructionCount, 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(g_destructionCount, 2u, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliIntrusivePtrResetTN(void)
{
- tet_infoline( "Negative Test for Dali::IntrusivePtr::Reset(T*)" );
+ tet_infoline("Negative Test for Dali::IntrusivePtr::Reset(T*)");
g_creationCount = g_destructionCount = 0;
- IntrusivePtr<Counted> counted( new Counted );
+ IntrusivePtr<Counted> counted(new Counted);
- counted.Reset( (Counted*) 0 );
+ counted.Reset((Counted*)0);
- DALI_TEST_EQUALS( counted.Get(), (Counted*) 0, TEST_LOCATION );
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( g_destructionCount, 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(counted.Get(), (Counted*)0, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 1u, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliIntrusivePtrOperatorBooleanTypeP(void)
{
- tet_infoline( "Positive Test for Dali::IntrusivePtr::operator Booleantype()" );
+ tet_infoline("Positive Test for Dali::IntrusivePtr::operator Booleantype()");
- IntrusivePtr<Counted> counted( new Counted );
- DALI_TEST_CHECK( counted.operator BooleanType() != 0 );
- DALI_TEST_CHECK( counted );
+ IntrusivePtr<Counted> counted(new Counted);
+ DALI_TEST_CHECK(counted.operator BooleanType() != 0);
+ DALI_TEST_CHECK(counted);
typedef void (IntrusivePtr<Counted>::*BoolIdiomFunc)() const;
- BoolIdiomFunc func = static_cast<BoolIdiomFunc>( counted.operator BooleanType() );
+ BoolIdiomFunc func = static_cast<BoolIdiomFunc>(counted.operator BooleanType());
((counted).*func)(); // purely for test coverage
counted.Reset();
- DALI_TEST_CHECK( counted.operator BooleanType() == 0 );
+ DALI_TEST_CHECK(counted.operator BooleanType() == 0);
END_TEST;
}
int UtcDaliIntrusivePtrOperatorBooleanTypeN(void)
{
- tet_infoline( "Negative Test for Dali::IntrusivePtr::operator Booleantype()" );
+ tet_infoline("Negative Test for Dali::IntrusivePtr::operator Booleantype()");
IntrusivePtr<Counted> counted;
- DALI_TEST_CHECK( counted.operator BooleanType() == 0 );
- DALI_TEST_CHECK( !counted );
+ DALI_TEST_CHECK(counted.operator BooleanType() == 0);
+ DALI_TEST_CHECK(!counted);
END_TEST;
}
/** Equality of two different types*/
int UtcDaliIntrusivePtrOperatorEqualTU(void)
{
- tet_infoline( "Test for Dali::IntrusivePtr::operator ==(T, U)" );
+ tet_infoline("Test for Dali::IntrusivePtr::operator ==(T, U)");
- IntrusivePtr<Counted> counted1( new Counted );
- IntrusivePtr<CountedSubclass> countedSubclass1( new CountedSubclass );
- IntrusivePtr<CountedSubclass> countedSubclass2( new CountedSubclass );
- IntrusivePtr<Counted> counted2( countedSubclass2 );
+ IntrusivePtr<Counted> counted1(new Counted);
+ IntrusivePtr<CountedSubclass> countedSubclass1(new CountedSubclass);
+ IntrusivePtr<CountedSubclass> countedSubclass2(new CountedSubclass);
+ IntrusivePtr<Counted> counted2(countedSubclass2);
- DALI_TEST_EQUALS( operator==( counted1, countedSubclass1 ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( operator==( counted2, countedSubclass2 ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(operator==(counted1, countedSubclass1), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(operator==(counted2, countedSubclass2), true, TEST_LOCATION);
END_TEST;
}
/** Inequality of two different types*/
int UtcDaliIntrusivePtrOperatorNotEqualTU(void)
{
- tet_infoline( "Test for Dali::IntrusivePtr::operator !=(T, U)" );
+ tet_infoline("Test for Dali::IntrusivePtr::operator !=(T, U)");
- IntrusivePtr<Counted> counted1( new Counted );
- IntrusivePtr<CountedSubclass> countedSubclass1( new CountedSubclass );
- IntrusivePtr<CountedSubclass> countedSubclass2( new CountedSubclass );
- IntrusivePtr<Counted> counted2( countedSubclass2 );
+ IntrusivePtr<Counted> counted1(new Counted);
+ IntrusivePtr<CountedSubclass> countedSubclass1(new CountedSubclass);
+ IntrusivePtr<CountedSubclass> countedSubclass2(new CountedSubclass);
+ IntrusivePtr<Counted> counted2(countedSubclass2);
- DALI_TEST_EQUALS( operator!=( counted1, countedSubclass1 ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( operator!=( counted2, countedSubclass2 ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(operator!=(counted1, countedSubclass1), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(operator!=(counted2, countedSubclass2), false, TEST_LOCATION);
END_TEST;
}
/** Equality of two different types where right hand side is a raw pointer */
int UtcDaliIntrusivePtrOperatorEqualRightPointerTU(void)
{
- tet_infoline( "Test for Dali::IntrusivePtr::operator ==(T, U*)" );
+ tet_infoline("Test for Dali::IntrusivePtr::operator ==(T, U*)");
- IntrusivePtr<Counted> counted1( new Counted );
- IntrusivePtr<CountedSubclass> countedSubclass1( new CountedSubclass );
- IntrusivePtr<CountedSubclass> countedSubclass2( new CountedSubclass );
- IntrusivePtr<Counted> counted2( countedSubclass2 );
+ IntrusivePtr<Counted> counted1(new Counted);
+ IntrusivePtr<CountedSubclass> countedSubclass1(new CountedSubclass);
+ IntrusivePtr<CountedSubclass> countedSubclass2(new CountedSubclass);
+ IntrusivePtr<Counted> counted2(countedSubclass2);
- DALI_TEST_EQUALS( operator==( counted1, countedSubclass1.Get() ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( operator==( counted2, countedSubclass2.Get() ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(operator==(counted1, countedSubclass1.Get()), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(operator==(counted2, countedSubclass2.Get()), true, TEST_LOCATION);
END_TEST;
}
/** Inequality of two different types where the right hand side is a raw pointer */
int UtcDaliIntrusivePtrOperatorNotEqualRightPointerTU(void)
{
- tet_infoline( "Test for Dali::IntrusivePtr::operator !=(T, U*)" );
+ tet_infoline("Test for Dali::IntrusivePtr::operator !=(T, U*)");
- IntrusivePtr<Counted> counted1( new Counted );
- IntrusivePtr<CountedSubclass> countedSubclass1( new CountedSubclass );
- IntrusivePtr<CountedSubclass> countedSubclass2( new CountedSubclass );
- IntrusivePtr<Counted> counted2( countedSubclass2 );
+ IntrusivePtr<Counted> counted1(new Counted);
+ IntrusivePtr<CountedSubclass> countedSubclass1(new CountedSubclass);
+ IntrusivePtr<CountedSubclass> countedSubclass2(new CountedSubclass);
+ IntrusivePtr<Counted> counted2(countedSubclass2);
- DALI_TEST_EQUALS( operator!=( counted1, countedSubclass1.Get() ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( operator!=( counted2, countedSubclass2.Get() ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(operator!=(counted1, countedSubclass1.Get()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(operator!=(counted2, countedSubclass2.Get()), false, TEST_LOCATION);
END_TEST;
}
/** Equality of two different types where left hand side is a raw pointer */
int UtcDaliIntrusivePtrOperatorEqualLeftPointerTU(void)
{
- tet_infoline( "Test for Dali::IntrusivePtr::operator ==(T*, U)" );
+ tet_infoline("Test for Dali::IntrusivePtr::operator ==(T*, U)");
- IntrusivePtr<Counted> counted1( new Counted );
- IntrusivePtr<CountedSubclass> countedSubclass1( new CountedSubclass );
- IntrusivePtr<CountedSubclass> countedSubclass2( new CountedSubclass );
- IntrusivePtr<Counted> counted2( countedSubclass2 );
+ IntrusivePtr<Counted> counted1(new Counted);
+ IntrusivePtr<CountedSubclass> countedSubclass1(new CountedSubclass);
+ IntrusivePtr<CountedSubclass> countedSubclass2(new CountedSubclass);
+ IntrusivePtr<Counted> counted2(countedSubclass2);
- DALI_TEST_EQUALS( operator==( counted1.Get(), countedSubclass1 ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( operator==( counted2.Get(), countedSubclass2 ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(operator==(counted1.Get(), countedSubclass1), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(operator==(counted2.Get(), countedSubclass2), true, TEST_LOCATION);
END_TEST;
}
/** Inequality of two different types where the left hand side is a raw pointer */
int UtcDaliIntrusivePtrOperatorNotEqualLeftPointerTU(void)
{
- tet_infoline( "Test for Dali::IntrusivePtr::operator !=(T*, U)" );
+ tet_infoline("Test for Dali::IntrusivePtr::operator !=(T*, U)");
- IntrusivePtr<Counted> counted1( new Counted );
- IntrusivePtr<CountedSubclass> countedSubclass1( new CountedSubclass );
- IntrusivePtr<CountedSubclass> countedSubclass2( new CountedSubclass );
- IntrusivePtr<Counted> counted2( countedSubclass2 );
+ IntrusivePtr<Counted> counted1(new Counted);
+ IntrusivePtr<CountedSubclass> countedSubclass1(new CountedSubclass);
+ IntrusivePtr<CountedSubclass> countedSubclass2(new CountedSubclass);
+ IntrusivePtr<Counted> counted2(countedSubclass2);
- DALI_TEST_EQUALS( operator!=( counted1.Get(), countedSubclass1 ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( operator!=( counted2.Get(), countedSubclass2 ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(operator!=(counted1.Get(), countedSubclass1), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(operator!=(counted2.Get(), countedSubclass2), false, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test for Dali::RefObject(const RefObject&)");
{
- IntrusivePtr<TestObject> testPtr( new TestObject );
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<TestObject> testPtr(new TestObject);
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
- const TestObject& testObject=*testPtr.Get();
+ const TestObject& testObject = *testPtr.Get();
{
- IntrusivePtr<TestObject> testPtr2( new TestObject(testObject) );
- DALI_TEST_EQUALS( testPtr2->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<TestObject> testPtr2(new TestObject(testObject));
+ DALI_TEST_EQUALS(testPtr2->ReferenceCount(), 1, TEST_LOCATION);
}
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRefObjectAssignmentOperator(void)
{
tet_infoline("Test for Dali::RefObject::operator=(const RefObject&)");
{
- IntrusivePtr<TestObject> testPtr( new TestObject );
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<TestObject> testPtr(new TestObject);
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
- const TestObject& testObject=*testPtr.Get();
+ const TestObject& testObject = *testPtr.Get();
{
- IntrusivePtr<TestObject> testPtr2( new TestObject() );
- testPtr->data = 33;
+ IntrusivePtr<TestObject> testPtr2(new TestObject());
+ testPtr->data = 33;
IntrusivePtr<TestObject> testPtr3 = testPtr2;
- DALI_TEST_EQUALS( testPtr2->ReferenceCount(), 2, TEST_LOCATION );
- DALI_TEST_EQUALS( testPtr2->data, 201, TEST_LOCATION );
+ DALI_TEST_EQUALS(testPtr2->ReferenceCount(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(testPtr2->data, 201, TEST_LOCATION);
TestObject& testObject2 = *testPtr2.Get();
- testObject2 = testObject;
+ testObject2 = testObject;
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( testPtr2->ReferenceCount(), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(testPtr2->ReferenceCount(), 2, TEST_LOCATION);
}
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRefObjectAssignmentOperatorToNull(void)
{
tet_infoline("Testing Dali::IntrusivePtr = nullptr");
g_creationCount = g_destructionCount = 0;
- IntrusivePtr<Counted> counted( new Counted );
+ IntrusivePtr<Counted> counted(new Counted);
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION);
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
IntrusivePtr<Counted> counted2 = counted;
- DALI_TEST_EQUALS( g_creationCount, 1u, TEST_LOCATION);
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_creationCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
- DALI_TEST_EQUALS( counted->ReferenceCount(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 2, TEST_LOCATION);
counted2 = nullptr;
- DALI_TEST_EQUALS( g_destructionCount, 0u, TEST_LOCATION);
- DALI_TEST_EQUALS( counted->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(counted->ReferenceCount(), 1, TEST_LOCATION);
counted = nullptr;
- DALI_TEST_EQUALS( g_destructionCount, 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(g_destructionCount, 1u, TEST_LOCATION);
END_TEST;
}
int UtcDaliIntrusivePtrMoveConstructor(void)
{
- IntrusivePtr<TestObject> testPtr( new TestObject );
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( testPtr->data, 201, TEST_LOCATION );
+ IntrusivePtr<TestObject> testPtr(new TestObject);
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(testPtr->data, 201, TEST_LOCATION);
- IntrusivePtr<TestObject> movePtr = std::move( testPtr );
- DALI_TEST_EQUALS( movePtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( movePtr->data, 201, TEST_LOCATION );
- DALI_TEST_CHECK( !testPtr );
+ IntrusivePtr<TestObject> movePtr = std::move(testPtr);
+ DALI_TEST_EQUALS(movePtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(movePtr->data, 201, TEST_LOCATION);
+ DALI_TEST_CHECK(!testPtr);
- IntrusivePtr<TestObject> anotherTestPtr( new TestObject );
- DALI_TEST_EQUALS( anotherTestPtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( anotherTestPtr->data, 201, TEST_LOCATION );
- IntrusivePtr<TestObject> anotherMovePtr = std::move( anotherTestPtr );
- DALI_TEST_EQUALS( anotherMovePtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( anotherMovePtr->data, 201, TEST_LOCATION );
- DALI_TEST_CHECK( !anotherTestPtr.Get() );
+ IntrusivePtr<TestObject> anotherTestPtr(new TestObject);
+ DALI_TEST_EQUALS(anotherTestPtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(anotherTestPtr->data, 201, TEST_LOCATION);
+ IntrusivePtr<TestObject> anotherMovePtr = std::move(anotherTestPtr);
+ DALI_TEST_EQUALS(anotherMovePtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(anotherMovePtr->data, 201, TEST_LOCATION);
+ DALI_TEST_CHECK(!anotherTestPtr.Get());
- IntrusivePtr<CountedSubclass> countedSubclass( new CountedSubclass );
- DALI_TEST_EQUALS( countedSubclass->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<CountedSubclass> countedSubclass(new CountedSubclass);
+ DALI_TEST_EQUALS(countedSubclass->ReferenceCount(), 1, TEST_LOCATION);
- IntrusivePtr<Counted> countedMovePtr = std::move( countedSubclass );
- DALI_TEST_EQUALS( countedMovePtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_CHECK( !countedSubclass );
+ IntrusivePtr<Counted> countedMovePtr = std::move(countedSubclass);
+ DALI_TEST_EQUALS(countedMovePtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_CHECK(!countedSubclass);
END_TEST;
}
int UtcDaliIntrusivePtrMoveAssignment(void)
{
- IntrusivePtr<TestObject> testPtr( new TestObject );
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( testPtr->data, 201, TEST_LOCATION );
+ IntrusivePtr<TestObject> testPtr(new TestObject);
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(testPtr->data, 201, TEST_LOCATION);
- IntrusivePtr<TestObject> secondPtr( testPtr );
- DALI_TEST_EQUALS( testPtr->ReferenceCount(), 2, TEST_LOCATION );
+ IntrusivePtr<TestObject> secondPtr(testPtr);
+ DALI_TEST_EQUALS(testPtr->ReferenceCount(), 2, TEST_LOCATION);
IntrusivePtr<TestObject> thirdPtr;
- testPtr = std::move( thirdPtr );
- DALI_TEST_EQUALS( secondPtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( secondPtr->data, 201, TEST_LOCATION );
- DALI_TEST_CHECK( !testPtr.Get() );
+ testPtr = std::move(thirdPtr);
+ DALI_TEST_EQUALS(secondPtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(secondPtr->data, 201, TEST_LOCATION);
+ DALI_TEST_CHECK(!testPtr.Get());
- IntrusivePtr<TestObject> fourthPtr( new TestObject );
- testPtr = std::move( fourthPtr );
- DALI_TEST_CHECK( !fourthPtr.Get() );
+ IntrusivePtr<TestObject> fourthPtr(new TestObject);
+ testPtr = std::move(fourthPtr);
+ DALI_TEST_CHECK(!fourthPtr.Get());
- IntrusivePtr<CountedSubclass> countedSubclassPtr( new CountedSubclass );
- DALI_TEST_EQUALS( countedSubclassPtr->ReferenceCount(), 1, TEST_LOCATION );
+ IntrusivePtr<CountedSubclass> countedSubclassPtr(new CountedSubclass);
+ DALI_TEST_EQUALS(countedSubclassPtr->ReferenceCount(), 1, TEST_LOCATION);
IntrusivePtr<Counted> countedMovePtr;
- countedMovePtr = std::move( countedSubclassPtr );
- DALI_TEST_EQUALS( countedMovePtr->ReferenceCount(), 1, TEST_LOCATION );
- DALI_TEST_CHECK( !countedSubclassPtr );
+ countedMovePtr = std::move(countedSubclassPtr);
+ DALI_TEST_EQUALS(countedMovePtr->ReferenceCount(), 1, TEST_LOCATION);
+ DALI_TEST_CHECK(!countedSubclassPtr);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/events/key-event-integ.h>
+#include <dali-test-suite-utils.h>
#include <dali/devel-api/events/key-event-devel.h>
+#include <dali/integration-api/events/key-event-integ.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
using namespace Dali;
namespace
{
-
// Key Event Test references
-const static int SHIFT_MODIFIER = 0x1;
-const static int CTRL_MODIFIER = 0x2;
-const static int ALT_MODIFIER = 0x4;
-const static int SHIFT_AND_CTRL_MODIFIER = SHIFT_MODIFIER | CTRL_MODIFIER;
+const static int SHIFT_MODIFIER = 0x1;
+const static int CTRL_MODIFIER = 0x2;
+const static int ALT_MODIFIER = 0x4;
+const static int SHIFT_AND_CTRL_MODIFIER = SHIFT_MODIFIER | CTRL_MODIFIER;
const static int SHIFT_AND_ALT_MODIFIER = SHIFT_MODIFIER | ALT_MODIFIER;
-const static int CTRL_AND_ALT_MODIFIER = CTRL_MODIFIER | ALT_MODIFIER;
+const static int CTRL_AND_ALT_MODIFIER = CTRL_MODIFIER | ALT_MODIFIER;
const static char* TEST_STRING_1 = "alpha";
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
SignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
keyedActor.Reset();
}
- bool functorCalled;
+ bool functorCalled;
KeyEvent receivedKeyEvent;
- Actor keyedActor;
+ Actor keyedActor;
};
// Functor that sets the data when called
struct KeyEventReceivedFunctor
{
- KeyEventReceivedFunctor( SignalData& data ) : signalData( data ) { }
+ KeyEventReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( Actor actor, const KeyEvent& keyEvent )
+ bool operator()(Actor actor, const KeyEvent& keyEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedKeyEvent = keyEvent;
- signalData.keyedActor = actor;
+ signalData.keyedActor = actor;
return true;
}
SignalData& signalData;
};
-} // anon namespace
+} // namespace
int UtcDaliKeyEventConstructor(void)
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
END_TEST;
int UtcDaliKeyEventCopyAssignment(void)
{
// Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
- Dali::KeyEvent event2 = DevelKeyEvent::New(TEST_STRING_1, "J", "j", 88, CTRL_MODIFIER, 0lu, KeyEvent::UP, "", "", Device::Class::USER, Device::Subclass::FINGER); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event2 );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event2.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("J", event2.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("j", event2.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(88, event2.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(CTRL_MODIFIER, event2.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event2.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::UP, event2.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event2.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event2.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::USER, event2.GetDeviceClass(), TEST_LOCATION); // check device class
+ Dali::KeyEvent event2 = DevelKeyEvent::New(TEST_STRING_1, "J", "j", 88, CTRL_MODIFIER, 0lu, KeyEvent::UP, "", "", Device::Class::USER, Device::Subclass::FINGER); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event2);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event2.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("J", event2.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("j", event2.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(88, event2.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event2.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event2.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::UP, event2.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event2.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event2.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::USER, event2.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::FINGER, event2.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
event = event2;
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("J", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("j", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(88, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::UP, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::USER, event.GetDeviceClass(), TEST_LOCATION); // check device class
+ DALI_TEST_CHECK(event);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("J", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("j", event.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(88, event.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::UP, event.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::USER, event.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::FINGER, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
END_TEST;
int UtcDaliKeyEventCopyConstructor(void)
{
// Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
- KeyEvent event2( event );
- DALI_TEST_CHECK( event2 );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event2.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event2.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event2.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event2.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event2.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event2.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, event2.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event2.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event2.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event2.GetDeviceClass(), TEST_LOCATION); // check device class
+ KeyEvent event2(event);
+ DALI_TEST_CHECK(event2);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event2.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", event2.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", event2.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event2.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event2.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event2.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event2.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event2.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event2.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, event2.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, event2.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
END_TEST;
int UtcDaliKeyEventMoveAssignment(void)
{
// Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
KeyEvent move;
- move = std::move( event );
- DALI_TEST_CHECK( move );
-
- DALI_TEST_EQUALS(TEST_STRING_1, move.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", move.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", move.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, move.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, move.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, move.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, move.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", move.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", move.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, move.GetDeviceClass(), TEST_LOCATION); // check device class
+ move = std::move(event);
+ DALI_TEST_CHECK(move);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, move.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", move.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", move.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, move.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, move.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, move.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, move.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", move.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", move.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, move.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, move.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
- DALI_TEST_CHECK( !event );
+ DALI_TEST_CHECK(!event);
END_TEST;
}
int UtcDaliKeyEventMoveConstructor(void)
{
// Test Assignment operator
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
-
- DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", event.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", event.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", event.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, event.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, event.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
- KeyEvent move = std::move( event );
- DALI_TEST_CHECK( move );
-
- DALI_TEST_EQUALS(TEST_STRING_1, move.GetKeyName(), TEST_LOCATION); // check key name
- DALI_TEST_EQUALS("I", move.GetLogicalKey(), TEST_LOCATION); // check logical key string
- DALI_TEST_EQUALS("i", move.GetKeyString(), TEST_LOCATION); // check key string
- DALI_TEST_EQUALS(99, move.GetKeyCode(), TEST_LOCATION); // check keyCode
- DALI_TEST_EQUALS(SHIFT_MODIFIER, move.GetKeyModifier(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(0lu, move.GetTime(), TEST_LOCATION); // check time
- DALI_TEST_EQUALS(KeyEvent::DOWN, move.GetState(), TEST_LOCATION); // check state
- DALI_TEST_EQUALS("", move.GetCompose(), TEST_LOCATION); // check compose
- DALI_TEST_EQUALS("", move.GetDeviceName(), TEST_LOCATION); // check device name
- DALI_TEST_EQUALS(Device::Class::NONE, move.GetDeviceClass(), TEST_LOCATION); // check device class
+ KeyEvent move = std::move(event);
+ DALI_TEST_CHECK(move);
+
+ DALI_TEST_EQUALS(TEST_STRING_1, move.GetKeyName(), TEST_LOCATION); // check key name
+ DALI_TEST_EQUALS("I", move.GetLogicalKey(), TEST_LOCATION); // check logical key string
+ DALI_TEST_EQUALS("i", move.GetKeyString(), TEST_LOCATION); // check key string
+ DALI_TEST_EQUALS(99, move.GetKeyCode(), TEST_LOCATION); // check keyCode
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, move.GetKeyModifier(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0lu, move.GetTime(), TEST_LOCATION); // check time
+ DALI_TEST_EQUALS(KeyEvent::DOWN, move.GetState(), TEST_LOCATION); // check state
+ DALI_TEST_EQUALS("", move.GetCompose(), TEST_LOCATION); // check compose
+ DALI_TEST_EQUALS("", move.GetDeviceName(), TEST_LOCATION); // check device name
+ DALI_TEST_EQUALS(Device::Class::NONE, move.GetDeviceClass(), TEST_LOCATION); // check device class
DALI_TEST_EQUALS(Device::Subclass::NONE, move.GetDeviceSubclass(), TEST_LOCATION); // check device subclass
- DALI_TEST_CHECK( !event );
+ DALI_TEST_CHECK(!event);
END_TEST;
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, CTRL_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, CTRL_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
DALI_TEST_EQUALS(false, event.IsShiftModifier(), TEST_LOCATION); // check IsShiftModifier
- DevelKeyEvent::SetKeyModifier( event, SHIFT_MODIFIER ); // Set to Shift Modifier
+ DevelKeyEvent::SetKeyModifier(event, SHIFT_MODIFIER); // Set to Shift Modifier
DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check able to set
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
DALI_TEST_EQUALS(false, event.IsCtrlModifier(), TEST_LOCATION); // check IsCtrlModifier
- DevelKeyEvent::SetKeyModifier( event, CTRL_MODIFIER ); // Set to Ctrl Modifier
+ DevelKeyEvent::SetKeyModifier(event, CTRL_MODIFIER); // Set to Ctrl Modifier
DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check able to set
{
TestApplication application; // Reset all test adapter return codes
- Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
- DALI_TEST_CHECK( event );
+ Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE); // set name to test, key string to i and modifier to shift
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
DALI_TEST_EQUALS(false, event.IsAltModifier(), TEST_LOCATION); // check IsAltModifier
- DevelKeyEvent::SetKeyModifier( event, ALT_MODIFIER ); // Set to Alt Modifier
+ DevelKeyEvent::SetKeyModifier(event, ALT_MODIFIER); // Set to Alt Modifier
DALI_TEST_EQUALS(ALT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION); // check able to set
- DALI_TEST_EQUALS(true, event.IsAltModifier(), TEST_LOCATION); // IsAltModifier
+ DALI_TEST_EQUALS(true, event.IsAltModifier(), TEST_LOCATION); // IsAltModifier
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, SHIFT_AND_CTRL_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
DALI_TEST_EQUALS(true, (bool)(event.IsCtrlModifier() & event.IsShiftModifier()), TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, SHIFT_MODIFIER ); // Set to Shift Modifier
+ DevelKeyEvent::SetKeyModifier(event, SHIFT_MODIFIER); // Set to Shift Modifier
DALI_TEST_EQUALS(false, (bool)(event.IsCtrlModifier() & event.IsShiftModifier()), TEST_LOCATION);
END_TEST;
Dali::KeyEvent event = DevelKeyEvent::New("i", "I", "i", 0, SHIFT_AND_CTRL_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
DALI_TEST_EQUALS(true, (bool)(event.IsCtrlModifier() | event.IsAltModifier()), TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, SHIFT_MODIFIER ); // Set to Shift Modifier
+ DevelKeyEvent::SetKeyModifier(event, SHIFT_MODIFIER); // Set to Shift Modifier
DALI_TEST_EQUALS(false, (bool)(event.IsCtrlModifier() & event.IsAltModifier()), TEST_LOCATION);
END_TEST;
{
Integration::KeyEvent keyEvent;
- DALI_TEST_EQUALS( keyEvent.type, Integration::Event::Key, TEST_LOCATION );
- DALI_TEST_CHECK( keyEvent.keyName == std::string() );
- DALI_TEST_CHECK( keyEvent.logicalKey == std::string() );
- DALI_TEST_CHECK( keyEvent.keyString == std::string() );
- DALI_TEST_EQUALS( keyEvent.keyCode, -1, TEST_LOCATION );
- DALI_TEST_EQUALS( keyEvent.keyModifier, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( keyEvent.time, 0lu, TEST_LOCATION );
- DALI_TEST_EQUALS( keyEvent.state, Integration::KeyEvent::DOWN, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.compose, std::string(), TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceName, std::string(), TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceClass, Device::Class::NONE, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceSubclass, Device::Subclass::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.type, Integration::Event::Key, TEST_LOCATION);
+ DALI_TEST_CHECK(keyEvent.keyName == std::string());
+ DALI_TEST_CHECK(keyEvent.logicalKey == std::string());
+ DALI_TEST_CHECK(keyEvent.keyString == std::string());
+ DALI_TEST_EQUALS(keyEvent.keyCode, -1, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.keyModifier, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.time, 0lu, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.state, Integration::KeyEvent::DOWN, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.compose, std::string(), TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.deviceName, std::string(), TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.deviceClass, Device::Class::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.deviceSubclass, Device::Subclass::NONE, TEST_LOCATION);
}
{
- const std::string keyName("keyName");
- const std::string logicalKey("logicalKey");
- const std::string keyString("keyString");
- const int keyCode(333);
- const int keyModifier(312);
- const unsigned long timeStamp(132);
+ const std::string keyName("keyName");
+ const std::string logicalKey("logicalKey");
+ const std::string keyString("keyString");
+ const int keyCode(333);
+ const int keyModifier(312);
+ const unsigned long timeStamp(132);
const Integration::KeyEvent::State keyState(Integration::KeyEvent::UP);
- const std::string compose("compose");
- const std::string deviceName("hwKeyboard");
- const Device::Class::Type deviceClass = Device::Class::KEYBOARD;
- const Device::Subclass::Type deviceSubclass = Device::Subclass::NONE;
-
- Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass );
- DALI_TEST_EQUALS( keyEvent.type, Integration::Event::Key, TEST_LOCATION );
- DALI_TEST_CHECK( keyEvent.keyName == keyName );
- DALI_TEST_CHECK( keyEvent.logicalKey == logicalKey );
- DALI_TEST_CHECK( keyEvent.keyString == keyString );
- DALI_TEST_EQUALS( keyEvent.keyCode, keyCode, TEST_LOCATION );
- DALI_TEST_EQUALS( keyEvent.keyModifier, keyModifier, TEST_LOCATION );
- DALI_TEST_EQUALS( keyEvent.time, timeStamp, TEST_LOCATION );
- DALI_TEST_EQUALS( keyEvent.state, keyState, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.compose, compose, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceName, deviceName, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceClass, deviceClass, TEST_LOCATION);
- DALI_TEST_EQUALS( keyEvent.deviceSubclass, deviceSubclass, TEST_LOCATION);
+ const std::string compose("compose");
+ const std::string deviceName("hwKeyboard");
+ const Device::Class::Type deviceClass = Device::Class::KEYBOARD;
+ const Device::Subclass::Type deviceSubclass = Device::Subclass::NONE;
+
+ Integration::KeyEvent keyEvent(keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass);
+ DALI_TEST_EQUALS(keyEvent.type, Integration::Event::Key, TEST_LOCATION);
+ DALI_TEST_CHECK(keyEvent.keyName == keyName);
+ DALI_TEST_CHECK(keyEvent.logicalKey == logicalKey);
+ DALI_TEST_CHECK(keyEvent.keyString == keyString);
+ DALI_TEST_EQUALS(keyEvent.keyCode, keyCode, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.keyModifier, keyModifier, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.time, timeStamp, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.state, keyState, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.compose, compose, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.deviceName, deviceName, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.deviceClass, deviceClass, TEST_LOCATION);
+ DALI_TEST_EQUALS(keyEvent.deviceSubclass, deviceSubclass, TEST_LOCATION);
}
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
- DALI_TEST_EQUALS( TEST_STRING_1, event.GetKeyName(), TEST_LOCATION );
+ DALI_TEST_EQUALS(TEST_STRING_1, event.GetKeyName(), TEST_LOCATION);
- DevelKeyEvent::SetKeyName( event, "keyName" );
- DALI_TEST_EQUALS( "keyName", event.GetKeyName(), TEST_LOCATION );
+ DevelKeyEvent::SetKeyName(event, "keyName");
+ DALI_TEST_EQUALS("keyName", event.GetKeyName(), TEST_LOCATION);
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
- DALI_TEST_EQUALS( "i", event.GetKeyString(), TEST_LOCATION );
+ DALI_TEST_EQUALS("i", event.GetKeyString(), TEST_LOCATION);
- DevelKeyEvent::SetKeyString( event, "keyString" );
- DALI_TEST_EQUALS( "keyString", event.GetKeyString(), TEST_LOCATION );
+ DevelKeyEvent::SetKeyString(event, "keyString");
+ DALI_TEST_EQUALS("keyString", event.GetKeyString(), TEST_LOCATION);
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
- DALI_TEST_EQUALS( 99, event.GetKeyCode(), TEST_LOCATION );
+ DALI_TEST_EQUALS(99, event.GetKeyCode(), TEST_LOCATION);
- DevelKeyEvent::SetKeyCode( event, 88 );
- DALI_TEST_EQUALS( 88, event.GetKeyCode(), TEST_LOCATION );
+ DevelKeyEvent::SetKeyCode(event, 88);
+ DALI_TEST_EQUALS(88, event.GetKeyCode(), TEST_LOCATION);
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
- DALI_TEST_EQUALS( SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION );
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
- DevelKeyEvent::SetKeyModifier( event, ALT_MODIFIER );
- DALI_TEST_EQUALS( ALT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION );
+ DevelKeyEvent::SetKeyModifier(event, ALT_MODIFIER);
+ DALI_TEST_EQUALS(ALT_MODIFIER, event.GetKeyModifier(), TEST_LOCATION);
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
- DALI_TEST_EQUALS( 0lu, event.GetTime(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0lu, event.GetTime(), TEST_LOCATION);
- DevelKeyEvent::SetTime( event, 100lu );
- DALI_TEST_EQUALS( 100lu, event.GetTime(), TEST_LOCATION );
+ DevelKeyEvent::SetTime(event, 100lu);
+ DALI_TEST_EQUALS(100lu, event.GetTime(), TEST_LOCATION);
END_TEST;
}
Dali::KeyEvent event = DevelKeyEvent::New(TEST_STRING_1, "I", "i", 99, SHIFT_MODIFIER, 0lu, KeyEvent::DOWN, "", "", Device::Class::NONE, Device::Subclass::NONE);
- DALI_TEST_EQUALS( KeyEvent::DOWN, event.GetState(), TEST_LOCATION );
+ DALI_TEST_EQUALS(KeyEvent::DOWN, event.GetState(), TEST_LOCATION);
- DevelKeyEvent::SetState( event, KeyEvent::UP );
- DALI_TEST_EQUALS( KeyEvent::UP, event.GetState(), TEST_LOCATION );
+ DevelKeyEvent::SetState(event, KeyEvent::UP);
+ DALI_TEST_EQUALS(KeyEvent::UP, event.GetState(), TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-
+#include <dali-test-suite-utils.h>
#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-
int UtcDaliLayerNew(void)
{
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
DALI_TEST_CHECK(layer);
END_TEST;
TestApplication application;
tet_infoline("Testing Dali::Layer::DownCast()");
- Layer actor1 = Layer::New();
+ Layer actor1 = Layer::New();
Actor anActor = Actor::New();
anActor.Add(actor1);
Actor child = anActor.GetChildAt(0);
- Layer layer = DownCast< Layer >(child);
+ Layer layer = DownCast<Layer>(child);
DALI_TEST_CHECK(layer);
END_TEST;
TestApplication application;
tet_infoline("Testing Dali::Layer::DownCast()");
- Actor actor1 = Actor::New();
+ Actor actor1 = Actor::New();
Actor anActor = Actor::New();
anActor.Add(actor1);
Actor child = anActor.GetChildAt(0);
- Layer layer = DownCast< Layer >(child);
+ Layer layer = DownCast<Layer>(child);
DALI_TEST_CHECK(!layer);
Actor unInitialzedActor;
- layer = Layer::DownCast( unInitialzedActor );
+ layer = Layer::DownCast(unInitialzedActor);
DALI_TEST_CHECK(!layer);
END_TEST;
}
int UtcDaliLayerMoveConstructor(void)
{
TestApplication application;
- Layer layer = Layer::New();
- DALI_TEST_CHECK( layer );
- DALI_TEST_EQUALS( 1, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, layer.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
+ Layer layer = Layer::New();
+ DALI_TEST_CHECK(layer);
+ DALI_TEST_EQUALS(1, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, layer.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
- application.GetScene().Add( layer );
- DALI_TEST_EQUALS( 2, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, layer.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
+ application.GetScene().Add(layer);
+ DALI_TEST_EQUALS(2, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, layer.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
- Layer move = std::move( layer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, move.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
- DALI_TEST_CHECK( !layer );
+ Layer move = std::move(layer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, move.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
+ DALI_TEST_CHECK(!layer);
END_TEST;
}
int UtcDaliLayerMoveAssignment(void)
{
TestApplication application;
- Layer layer = Layer::New();
- DALI_TEST_CHECK( layer );
- DALI_TEST_EQUALS( 1, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, layer.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
+ Layer layer = Layer::New();
+ DALI_TEST_CHECK(layer);
+ DALI_TEST_EQUALS(1, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, layer.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
- application.GetScene().Add( layer );
- DALI_TEST_EQUALS( 2, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, layer.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
+ application.GetScene().Add(layer);
+ DALI_TEST_EQUALS(2, layer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, layer.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
Layer move;
- move = std::move( layer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, move.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
- DALI_TEST_CHECK( !layer );
+ move = std::move(layer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, move.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
+ DALI_TEST_CHECK(!layer);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::GetDepth()");
TestApplication application;
- Layer layer1 = Layer::New();
- Layer layer2 = Layer::New();
+ Layer layer1 = Layer::New();
+ Layer layer2 = Layer::New();
// layers are not on scene
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// root depth is 0
- Layer root = application.GetScene().GetLayer( 0 );
- DALI_TEST_EQUALS(root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ Layer root = application.GetScene().GetLayer(0);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
application.GetScene().Add(layer1);
application.GetScene().Add(layer2);
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::Raise()");
TestApplication application;
- Layer layer1 = Layer::New();
- Layer layer2 = Layer::New();
+ Layer layer1 = Layer::New();
+ Layer layer2 = Layer::New();
application.GetScene().Add(layer1);
application.GetScene().Add(layer2);
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
layer1.Raise();
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
// get root
- Layer root = application.GetScene().GetLayer( 0 );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ Layer root = application.GetScene().GetLayer(0);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
root.Raise();
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::Lower()");
TestApplication application;
- Layer layer1 = Layer::New();
- Layer layer2 = Layer::New();
+ Layer layer1 = Layer::New();
+ Layer layer2 = Layer::New();
application.GetScene().Add(layer1);
application.GetScene().Add(layer2);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
layer2.Lower();
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
// get root
- Layer root = application.GetScene().GetLayer( 0 );
+ Layer root = application.GetScene().GetLayer(0);
root.Lower();
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
layer2.Lower();
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::RaiseToTop()");
TestApplication application;
- Layer layer1 = Layer::New();
- Layer layer2 = Layer::New();
- Layer layer3 = Layer::New();
+ Layer layer1 = Layer::New();
+ Layer layer2 = Layer::New();
+ Layer layer3 = Layer::New();
application.GetScene().Add(layer1);
application.GetScene().Add(layer2);
application.GetScene().Add(layer3);
- Layer root = application.GetScene().GetLayer( 0 );
+ Layer root = application.GetScene().GetLayer(0);
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer3.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
layer1.RaiseToTop();
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
root.RaiseToTop();
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::LowerToBottom()");
TestApplication application;
- Layer layer1 = Layer::New();
- Layer layer2 = Layer::New();
- Layer layer3 = Layer::New();
+ Layer layer1 = Layer::New();
+ Layer layer2 = Layer::New();
+ Layer layer3 = Layer::New();
application.GetScene().Add(layer1);
application.GetScene().Add(layer2);
application.GetScene().Add(layer3);
- DALI_TEST_EQUALS(layer1.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer2.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION);
- DALI_TEST_EQUALS(layer3.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer1.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
layer3.LowerToBottom();
- DALI_TEST_EQUALS(layer3.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Layer layer = Layer::New();
- DALI_TEST_CHECK( !layer.GetProperty< bool >( Layer::Property::CLIPPING_ENABLE ) );
+ DALI_TEST_CHECK(!layer.GetProperty<bool>(Layer::Property::CLIPPING_ENABLE));
- layer.SetProperty( Layer::Property::CLIPPING_ENABLE, true );
- DALI_TEST_CHECK( layer.GetProperty< bool >( Layer::Property::CLIPPING_ENABLE ) );
+ layer.SetProperty(Layer::Property::CLIPPING_ENABLE, true);
+ DALI_TEST_CHECK(layer.GetProperty<bool>(Layer::Property::CLIPPING_ENABLE));
END_TEST;
}
TestApplication application;
Layer layer = Layer::New();
- DALI_TEST_CHECK( !layer.GetProperty< bool >( Layer::Property::CLIPPING_ENABLE ) );
+ DALI_TEST_CHECK(!layer.GetProperty<bool>(Layer::Property::CLIPPING_ENABLE));
END_TEST;
}
tet_infoline("Testing Dali::Layer::SetClippingBox()");
TestApplication application;
- ClippingBox testBox(5,6, 77,83);
+ ClippingBox testBox(5, 6, 77, 83);
Layer layer = Layer::New();
- DALI_TEST_CHECK(layer.GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX ) != testBox);
- layer.SetProperty( Layer::Property::CLIPPING_BOX, testBox );
- DALI_TEST_CHECK(layer.GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX ) == testBox);
+ DALI_TEST_CHECK(layer.GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX) != testBox);
+ layer.SetProperty(Layer::Property::CLIPPING_BOX, testBox);
+ DALI_TEST_CHECK(layer.GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX) == testBox);
END_TEST;
}
TestApplication application;
Layer layer = Layer::New();
- DALI_TEST_CHECK( layer.GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX ) == ClippingBox(0,0,0,0) );
+ DALI_TEST_CHECK(layer.GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX) == ClippingBox(0, 0, 0, 0));
END_TEST;
}
TestApplication application;
// create two transparent actors so there is something to sort
- Actor actor = CreateRenderableActor();
+ Actor actor = CreateRenderableActor();
Actor actor2 = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 1, 1 ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4(1, 1, 1, 0.5f ) ); // 50% transparent
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 1, 1 ) );
- actor2.SetProperty( Actor::Property::COLOR, Vector4(1, 1, 1, 0.5f ) ); // 50% transparent
+ actor.SetProperty(Actor::Property::SIZE, Vector2(1, 1));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1, 1, 1, 0.5f)); // 50% transparent
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(1, 1));
+ actor2.SetProperty(Actor::Property::COLOR, Vector4(1, 1, 1, 0.5f)); // 50% transparent
// add to scene
- application.GetScene().Add( actor );
- application.GetScene().Add( actor2 );
+ application.GetScene().Add(actor);
+ application.GetScene().Add(actor2);
- Layer root = application.GetScene().GetLayer( 0 );
+ Layer root = application.GetScene().GetLayer(0);
gTestSortFunctionCalled = 0;
root.SetSortFunction(TestSortFunction);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( gTestSortFunctionCalled > 0 );
+ DALI_TEST_CHECK(gTestSortFunctionCalled > 0);
END_TEST;
}
-
int UtcDaliLayerRaiseAbove(void)
{
tet_infoline("Testing Dali::Layer::RaiseAbove()");
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
// try to raise above root layer
- Layer root = application.GetScene().GetLayer( 0 );
- layer.RaiseAbove( root );
+ Layer root = application.GetScene().GetLayer(0);
+ layer.RaiseAbove(root);
// layer depth is zero as its not on scene
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// add to scene
- application.GetScene().Add( layer );
- layer.RaiseAbove( root );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
- root.RaiseAbove( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- layer.RaiseAbove( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
+ application.GetScene().Add(layer);
+ layer.RaiseAbove(root);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ root.RaiseAbove(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ layer.RaiseAbove(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// make another layer on the scene
Layer layer2 = Layer::New();
- application.GetScene().Add( layer2 );
- layer.RaiseAbove( layer2 );
- DALI_TEST_GREATER( layer.GetProperty< int >( Layer::Property::DEPTH ), layer2.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
- layer2.RaiseAbove( layer );
- DALI_TEST_GREATER( layer2.GetProperty< int >( Layer::Property::DEPTH ), layer.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
- root.RaiseAbove( layer2 );
- DALI_TEST_GREATER( root.GetProperty< int >( Layer::Property::DEPTH ), layer2.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
+ application.GetScene().Add(layer2);
+ layer.RaiseAbove(layer2);
+ DALI_TEST_GREATER(layer.GetProperty<int>(Layer::Property::DEPTH), layer2.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
+ layer2.RaiseAbove(layer);
+ DALI_TEST_GREATER(layer2.GetProperty<int>(Layer::Property::DEPTH), layer.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
+ root.RaiseAbove(layer2);
+ DALI_TEST_GREATER(root.GetProperty<int>(Layer::Property::DEPTH), layer2.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::RaiseBelow()");
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
// try to lower below root layer
- Layer root = application.GetScene().GetLayer( 0 );
- layer.LowerBelow( root );
+ Layer root = application.GetScene().GetLayer(0);
+ layer.LowerBelow(root);
// layer depth is zero as its not on scene
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// add to scene
- application.GetScene().Add( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
- layer.LowerBelow( root );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- root.LowerBelow( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
- layer.LowerBelow( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
+ application.GetScene().Add(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ layer.LowerBelow(root);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ root.LowerBelow(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ layer.LowerBelow(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
// make another layer on the scene
Layer layer2 = Layer::New();
- application.GetScene().Add( layer2 );
- layer.LowerBelow( layer2 );
- DALI_TEST_GREATER( layer2.GetProperty< int >( Layer::Property::DEPTH ), layer.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
- layer2.LowerBelow( layer );
- DALI_TEST_GREATER( layer.GetProperty< int >( Layer::Property::DEPTH ), layer2.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
- root.LowerBelow( layer2 );
- DALI_TEST_GREATER( layer2.GetProperty< int >( Layer::Property::DEPTH ), root.GetProperty< int >( Layer::Property::DEPTH ), TEST_LOCATION );
+ application.GetScene().Add(layer2);
+ layer.LowerBelow(layer2);
+ DALI_TEST_GREATER(layer2.GetProperty<int>(Layer::Property::DEPTH), layer.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
+ layer2.LowerBelow(layer);
+ DALI_TEST_GREATER(layer.GetProperty<int>(Layer::Property::DEPTH), layer2.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
+ root.LowerBelow(layer2);
+ DALI_TEST_GREATER(layer2.GetProperty<int>(Layer::Property::DEPTH), root.GetProperty<int>(Layer::Property::DEPTH), TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::MoveAbove()");
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
// try to raise above root layer
- Layer root = application.GetScene().GetLayer( 0 );
- layer.MoveAbove( root );
+ Layer root = application.GetScene().GetLayer(0);
+ layer.MoveAbove(root);
// layer depth is zero as its not on scene
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- root.MoveAbove( layer );
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ root.MoveAbove(layer);
// root depth is zero as layer is not on scene
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// add to scene
- application.GetScene().Add( layer );
- layer.MoveAbove( root );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- root.MoveAbove( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
+ application.GetScene().Add(layer);
+ layer.MoveAbove(root);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ root.MoveAbove(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
// make another layer on the scene
Layer layer2 = Layer::New();
- application.GetScene().Add( layer2 );
- layer.MoveAbove( layer2 );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), layer2.GetProperty< int >( Layer::Property::DEPTH ) + 1u, TEST_LOCATION );
- layer2.MoveAbove( root );
- DALI_TEST_EQUALS( layer2.GetProperty< int >( Layer::Property::DEPTH ), root.GetProperty< int >( Layer::Property::DEPTH ) + 1u, TEST_LOCATION );
- root.MoveAbove( layer );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), layer.GetProperty< int >( Layer::Property::DEPTH ) + 1u, TEST_LOCATION );
+ application.GetScene().Add(layer2);
+ layer.MoveAbove(layer2);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), layer2.GetProperty<int>(Layer::Property::DEPTH) + 1u, TEST_LOCATION);
+ layer2.MoveAbove(root);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), root.GetProperty<int>(Layer::Property::DEPTH) + 1u, TEST_LOCATION);
+ root.MoveAbove(layer);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), layer.GetProperty<int>(Layer::Property::DEPTH) + 1u, TEST_LOCATION);
Layer layer3 = Layer::New();
- application.GetScene().Add( layer3 );
- DALI_TEST_EQUALS( layer3.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION );
- root.MoveAbove( layer3 );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION );
- DALI_TEST_EQUALS( layer3.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetScene().GetLayer( 0 ).GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- layer3.MoveAbove( application.GetScene().GetLayer( 0 ) );
- DALI_TEST_EQUALS( layer3.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
+ application.GetScene().Add(layer3);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
+ root.MoveAbove(layer3);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetScene().GetLayer(0).GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ layer3.MoveAbove(application.GetScene().GetLayer(0));
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::MoveBelow()");
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
// try to raise above root layer
- Layer root = application.GetScene().GetLayer( 0 );
- layer.MoveBelow( root );
+ Layer root = application.GetScene().GetLayer(0);
+ layer.MoveBelow(root);
// layer depth is zero as its not on scene
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- root.MoveBelow( layer );
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ root.MoveBelow(layer);
// root depth is zero as layer is not on scene
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// add to scene
- application.GetScene().Add( layer );
- layer.MoveBelow( root );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
- root.MoveBelow( layer );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 0u, TEST_LOCATION );
+ application.GetScene().Add(layer);
+ layer.MoveBelow(root);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ root.MoveBelow(layer);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 0u, TEST_LOCATION);
// make another layer on the scene
Layer layer2 = Layer::New();
- application.GetScene().Add( layer2 );
- layer.MoveBelow( layer2 );
- DALI_TEST_EQUALS( layer.GetProperty< int >( Layer::Property::DEPTH ), layer2.GetProperty< int >( Layer::Property::DEPTH ) - 1u, TEST_LOCATION );
- layer2.MoveBelow( root );
- DALI_TEST_EQUALS( layer2.GetProperty< int >( Layer::Property::DEPTH ), root.GetProperty< int >( Layer::Property::DEPTH ) - 1u, TEST_LOCATION );
- root.MoveBelow( layer );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), layer.GetProperty< int >( Layer::Property::DEPTH ) - 1u, TEST_LOCATION );
+ application.GetScene().Add(layer2);
+ layer.MoveBelow(layer2);
+ DALI_TEST_EQUALS(layer.GetProperty<int>(Layer::Property::DEPTH), layer2.GetProperty<int>(Layer::Property::DEPTH) - 1u, TEST_LOCATION);
+ layer2.MoveBelow(root);
+ DALI_TEST_EQUALS(layer2.GetProperty<int>(Layer::Property::DEPTH), root.GetProperty<int>(Layer::Property::DEPTH) - 1u, TEST_LOCATION);
+ root.MoveBelow(layer);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), layer.GetProperty<int>(Layer::Property::DEPTH) - 1u, TEST_LOCATION);
Layer layer3 = Layer::New();
- application.GetScene().Add( layer3 );
- DALI_TEST_EQUALS( layer3.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION );
- root.MoveBelow( layer3 );
- DALI_TEST_EQUALS( root.GetProperty< int >( Layer::Property::DEPTH ), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( layer3.GetProperty< int >( Layer::Property::DEPTH ), 3u, TEST_LOCATION );
+ application.GetScene().Add(layer3);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
+ root.MoveBelow(layer3);
+ DALI_TEST_EQUALS(root.GetProperty<int>(Layer::Property::DEPTH), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(layer3.GetProperty<int>(Layer::Property::DEPTH), 3u, TEST_LOCATION);
END_TEST;
}
indices.push_back(Layer::Property::CONSUMES_TOUCH);
indices.push_back(Layer::Property::CONSUMES_HOVER);
- DALI_TEST_CHECK(actor.GetPropertyCount() == ( Actor::New().GetPropertyCount() + indices.size() ) );
+ DALI_TEST_CHECK(actor.GetPropertyCount() == (Actor::New().GetPropertyCount() + indices.size()));
for(std::vector<Property::Index>::iterator iter = indices.begin(); iter != indices.end(); ++iter)
{
- DALI_TEST_CHECK( *iter == actor.GetPropertyIndex(actor.GetPropertyName(*iter)) );
- DALI_TEST_CHECK( *iter == Layer::Property::DEPTH ? !actor.IsPropertyWritable(*iter) : actor.IsPropertyWritable(*iter) );
- DALI_TEST_CHECK( !actor.IsPropertyAnimatable(*iter) );
- DALI_TEST_CHECK( actor.GetPropertyType(*iter) == actor.GetPropertyType(*iter) ); // just checking call succeeds
+ DALI_TEST_CHECK(*iter == actor.GetPropertyIndex(actor.GetPropertyName(*iter)));
+ DALI_TEST_CHECK(*iter == Layer::Property::DEPTH ? !actor.IsPropertyWritable(*iter) : actor.IsPropertyWritable(*iter));
+ DALI_TEST_CHECK(!actor.IsPropertyAnimatable(*iter));
+ DALI_TEST_CHECK(actor.GetPropertyType(*iter) == actor.GetPropertyType(*iter)); // just checking call succeeds
}
// set/get one of them
- actor.SetProperty( Layer::Property::CLIPPING_BOX, ClippingBox( 0, 0, 0, 0 ) );
+ actor.SetProperty(Layer::Property::CLIPPING_BOX, ClippingBox(0, 0, 0, 0));
- ClippingBox testBox(10,20,30,40);
- DALI_TEST_CHECK(actor.GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX ) != testBox);
+ ClippingBox testBox(10, 20, 30, 40);
+ DALI_TEST_CHECK(actor.GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX) != testBox);
actor.SetProperty(Layer::Property::CLIPPING_BOX, Property::Value(Rect<int>(testBox)));
Property::Value v = actor.GetProperty(Layer::Property::CLIPPING_BOX);
DALI_TEST_CHECK(v.Get<Rect<int> >() == testBox);
- v = actor.GetCurrentProperty( Layer::Property::CLIPPING_BOX );
+ v = actor.GetCurrentProperty(Layer::Property::CLIPPING_BOX);
DALI_TEST_CHECK(v.Get<Rect<int> >() == testBox);
// set the same boundaries, but through a clipping box object
- actor.SetProperty( Layer::Property::CLIPPING_BOX, testBox );
- DALI_TEST_CHECK( actor.GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX ) == testBox );
+ actor.SetProperty(Layer::Property::CLIPPING_BOX, testBox);
+ DALI_TEST_CHECK(actor.GetProperty<Rect<int32_t> >(Layer::Property::CLIPPING_BOX) == testBox);
actor.SetProperty(Layer::Property::BEHAVIOR, Property::Value(Layer::LAYER_UI));
DALI_TEST_CHECK(Property::INTEGER == actor.GetPropertyType(Layer::Property::BEHAVIOR));
Property::Value behavior = actor.GetProperty(Layer::Property::BEHAVIOR);
- DALI_TEST_EQUALS( behavior.Get<Dali::Layer::Behavior>(), Layer::LAYER_UI, TEST_LOCATION );
+ DALI_TEST_EQUALS(behavior.Get<Dali::Layer::Behavior>(), Layer::LAYER_UI, TEST_LOCATION);
- behavior = actor.GetCurrentProperty( Layer::Property::BEHAVIOR );
- DALI_TEST_EQUALS( behavior.Get<Dali::Layer::Behavior>(), Layer::LAYER_UI, TEST_LOCATION );
+ behavior = actor.GetCurrentProperty(Layer::Property::BEHAVIOR);
+ DALI_TEST_EQUALS(behavior.Get<Dali::Layer::Behavior>(), Layer::LAYER_UI, TEST_LOCATION);
END_TEST;
}
// Note that Layer::Property::DEPTH_TEST does not depend on layer behavior,
// as 2D layers can still have depth tests performed on a per-renderer basis.
// Check default.
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Layer::Property::DEPTH_TEST ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Layer::Property::DEPTH_TEST));
// Check Set / Unset.
- actor.SetProperty(Layer::Property::DEPTH_TEST, true );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Layer::Property::DEPTH_TEST ) );
- actor.SetProperty(Layer::Property::DEPTH_TEST, false );
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Layer::Property::DEPTH_TEST ) );
+ actor.SetProperty(Layer::Property::DEPTH_TEST, true);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Layer::Property::DEPTH_TEST));
+ actor.SetProperty(Layer::Property::DEPTH_TEST, false);
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Layer::Property::DEPTH_TEST));
END_TEST;
}
{
tet_infoline("Testing Dali::Layer::CreateDestroy() ");
Layer* layer = new Layer;
- DALI_TEST_CHECK( layer );
+ DALI_TEST_CHECK(layer);
delete layer;
END_TEST;
}
int UtcDaliLayerPropertyIndices(void)
{
TestApplication application;
- Actor basicActor = Actor::New();
- Layer layer = Layer::New();
+ Actor basicActor = Actor::New();
+ Layer layer = Layer::New();
Property::IndexContainer indices;
- layer.GetPropertyIndices( indices );
- DALI_TEST_CHECK( indices.Size() > basicActor.GetPropertyCount() );
- DALI_TEST_EQUALS( indices.Size(), layer.GetPropertyCount(), TEST_LOCATION );
+ layer.GetPropertyIndices(indices);
+ DALI_TEST_CHECK(indices.Size() > basicActor.GetPropertyCount());
+ DALI_TEST_EQUALS(indices.Size(), layer.GetPropertyCount(), TEST_LOCATION);
END_TEST;
}
int UtcDaliLayerTouchConsumed(void)
{
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
- DALI_TEST_EQUALS( layer.GetProperty< bool >( Layer::Property::CONSUMES_TOUCH ), false, TEST_LOCATION );
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
- DALI_TEST_EQUALS( layer.GetProperty< bool >( Layer::Property::CONSUMES_TOUCH ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<bool>(Layer::Property::CONSUMES_TOUCH), false, TEST_LOCATION);
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
+ DALI_TEST_EQUALS(layer.GetProperty<bool>(Layer::Property::CONSUMES_TOUCH), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliLayerHoverConsumed(void)
{
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
- DALI_TEST_EQUALS( layer.GetProperty< bool >( Layer::Property::CONSUMES_HOVER ), false, TEST_LOCATION );
- layer.SetProperty( Layer::Property::CONSUMES_HOVER, true );
- DALI_TEST_EQUALS( layer.GetProperty< bool >( Layer::Property::CONSUMES_HOVER ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<bool>(Layer::Property::CONSUMES_HOVER), false, TEST_LOCATION);
+ layer.SetProperty(Layer::Property::CONSUMES_HOVER, true);
+ DALI_TEST_EQUALS(layer.GetProperty<bool>(Layer::Property::CONSUMES_HOVER), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliLayerClippingGLCalls(void)
{
- TestApplication application;
- const TestGlAbstraction::ScissorParams& glScissorParams( application.GetGlAbstraction().GetScissorParams() );
- Integration::Scene scene( application.GetScene() );
+ TestApplication application;
+ const TestGlAbstraction::ScissorParams& glScissorParams(application.GetGlAbstraction().GetScissorParams());
+ Integration::Scene scene(application.GetScene());
- ClippingBox testBox( 5, 6, 77, 83 );
- Layer layer = application.GetScene().GetRootLayer();
- layer.SetProperty( Layer::Property::CLIPPING_ENABLE, true );
- layer.SetProperty( Layer::Property::CLIPPING_BOX, testBox );
+ ClippingBox testBox(5, 6, 77, 83);
+ Layer layer = application.GetScene().GetRootLayer();
+ layer.SetProperty(Layer::Property::CLIPPING_ENABLE, true);
+ layer.SetProperty(Layer::Property::CLIPPING_BOX, testBox);
// Add at least one renderable actor so the GL calls are actually made
- Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor actor = CreateRenderableActor( img );
- scene.Add( actor );
+ Texture img = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor = CreateRenderableActor(img);
+ scene.Add(actor);
// flush the queue and render once
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( testBox.x, glScissorParams.x, TEST_LOCATION );
- DALI_TEST_EQUALS( testBox.y, (int)(scene.GetSize().height - glScissorParams.y - testBox.height), TEST_LOCATION ); // GL Coordinates are from bottom left
- DALI_TEST_EQUALS( testBox.width, glScissorParams.width, TEST_LOCATION );
- DALI_TEST_EQUALS( testBox.height, glScissorParams.height, TEST_LOCATION );
+ DALI_TEST_EQUALS(testBox.x, glScissorParams.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(testBox.y, (int)(scene.GetSize().height - glScissorParams.y - testBox.height), TEST_LOCATION); // GL Coordinates are from bottom left
+ DALI_TEST_EQUALS(testBox.width, glScissorParams.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(testBox.height, glScissorParams.height, TEST_LOCATION);
END_TEST;
}
int UtcDaliLayerBehaviour(void)
{
TestApplication application;
- Layer layer = Layer::New();
+ Layer layer = Layer::New();
- DALI_TEST_EQUALS( layer.GetProperty<Layer::Behavior>( Layer::Property::BEHAVIOR ), Dali::Layer::LAYER_UI, TEST_LOCATION );
- layer.SetProperty( Layer::Property::BEHAVIOR, Dali::Layer::LAYER_3D );
- DALI_TEST_EQUALS( layer.GetProperty<Layer::Behavior>( Layer::Property::BEHAVIOR ), Dali::Layer::LAYER_3D, TEST_LOCATION );
+ DALI_TEST_EQUALS(layer.GetProperty<Layer::Behavior>(Layer::Property::BEHAVIOR), Dali::Layer::LAYER_UI, TEST_LOCATION);
+ layer.SetProperty(Layer::Property::BEHAVIOR, Dali::Layer::LAYER_3D);
+ DALI_TEST_EQUALS(layer.GetProperty<Layer::Behavior>(Layer::Property::BEHAVIOR), Dali::Layer::LAYER_3D, TEST_LOCATION);
END_TEST;
}
-Actor CreateActor( bool withAlpha )
+Actor CreateActor(bool withAlpha)
{
- Texture texture = Texture::New(TextureType::TEXTURE_2D, withAlpha ? Pixel::Format::RGBA8888 : Pixel::Format::RGB888, 1u, 1u );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, withAlpha ? Pixel::Format::RGBA8888 : Pixel::Format::RGB888, 1u, 1u);
- Actor actor = CreateRenderableActor( texture );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ Actor actor = CreateRenderableActor(texture);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
return actor;
}
int UtcDaliLayer3DSort(void)
{
- tet_infoline( "Testing LAYER_3D sort coverage test" );
- TestApplication application;
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
+ tet_infoline("Testing LAYER_3D sort coverage test");
+ TestApplication application;
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- application.GetScene().GetRootLayer().SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
+ application.GetScene().GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
// Create an actor.
- Actor actor = CreateActor( false );
- application.GetScene().Add( actor );
+ Actor actor = CreateActor(false);
+ application.GetScene().Add(actor);
// Create child actors.
- Actor child1 = CreateActor( true );
- actor.Add( child1 );
- Actor child2 = CreateActor( false );
- child1.Add( child2 );
+ Actor child1 = CreateActor(true);
+ actor.Add(child1);
+ Actor child2 = CreateActor(false);
+ child1.Add(child2);
enabledDisableTrace.Reset();
- enabledDisableTrace.Enable( true );
+ enabledDisableTrace.Enable(true);
application.SendNotification();
application.Render();
- enabledDisableTrace.Enable( false );
+ enabledDisableTrace.Enable(false);
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "2929" ) ); // 2929 is GL_DEPTH_TEST
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "2929")); // 2929 is GL_DEPTH_TEST
END_TEST;
}
int UtcDaliLayerLowerBelowNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
Dali::Layer arg1;
int UtcDaliLayerRaiseAboveNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
Dali::Layer arg1;
int UtcDaliLayerRaiseToTopNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
instance.RaiseToTop();
int UtcDaliLayerLowerToBottomNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
instance.LowerToBottom();
int UtcDaliLayerSetSortFunctionNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
Layer::SortFunctionType function = nullptr;
int UtcDaliLayerLowerNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
instance.Lower();
int UtcDaliLayerRaiseNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
instance.Raise();
int UtcDaliLayerMoveAboveNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
Dali::Layer arg1;
int UtcDaliLayerMoveBelowNegative(void)
{
TestApplication application;
- Dali::Layer instance;
+ Dali::Layer instance;
try
{
Dali::Layer arg1;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/lockless-buffer.h>
#include <dali-test-suite-utils.h>
+#include <dali/integration-api/lockless-buffer.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
static bool ReadTest(Integration::LocklessBuffer& buf, const unsigned char exp[], size_t size)
{
- const unsigned char *res = buf.Read();
- for (size_t i=0; i<size; ++i, ++res)
+ const unsigned char* res = buf.Read();
+ for(size_t i = 0; i < size; ++i, ++res)
{
if(*res != exp[i])
{
}
} // anonymous namespace
-
// Simple write - read test
int UtcDaliLocklessBufferWriteRead01(void)
{
Integration::LocklessBuffer buf(10);
- unsigned char data[10];
+ unsigned char data[10];
- for( unsigned char i=0; i<10; ++i )
+ for(unsigned char i = 0; i < 10; ++i)
{
- data[i]=i;
+ data[i] = i;
}
- buf.Write( &data[0], 10 );
+ buf.Write(&data[0], 10);
- if( ReadTest( buf, data, 10 ) )
+ if(ReadTest(buf, data, 10))
{
tet_result(TET_PASS);
}
int UtcDaliLocklessBufferMultipleWrites01(void)
{
Integration::LocklessBuffer buf(10);
- unsigned char data[10];
+ unsigned char data[10];
- for( unsigned char i=0; i<10; ++i )
+ for(unsigned char i = 0; i < 10; ++i)
{
- data[i]=i;
+ data[i] = i;
}
// Write to a buffer
- buf.Write( &data[0], 10 );
+ buf.Write(&data[0], 10);
- for (unsigned char i=0; i<10; ++i)
+ for(unsigned char i = 0; i < 10; ++i)
{
- data[i]=i+4;
+ data[i] = i + 4;
}
// No reads from buffer, so will overwrite contents of same buffer
- buf.Write( &data[0], 10 );
+ buf.Write(&data[0], 10);
- if( ReadTest(buf, data, 10) )
+ if(ReadTest(buf, data, 10))
{
tet_result(TET_PASS);
}
int UtcDaliLocklessBufferGetSize01(void)
{
Integration::LocklessBuffer buf(10);
- unsigned int size = buf.GetSize();
- if( size == 10 )
+ unsigned int size = buf.GetSize();
+ if(size == 10)
{
tet_result(TET_PASS);
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/long-press-gesture-detector-devel.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/input-options.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali/devel-api/events/long-press-gesture-detector-devel.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
#include <test-touch-event-utils.h>
+#include <iostream>
+
using namespace Dali;
void utc_dali_long_press_gesture_detector_startup(void)
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
SignalData()
- : functorCalled( false ),
- voidFunctorCalled( false ),
+ : functorCalled(false),
+ voidFunctorCalled(false),
receivedGesture(),
pressedActor()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pressedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
LongPressGesture receivedGesture;
- Actor pressedActor;
+ Actor pressedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const LongPressGesture& longPress)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = longPress;
- signalData.pressedActor = actor;
+ signalData.pressedActor = actor;
}
void operator()()
// Functor that removes the gestured actor from stage
struct UnstageActorFunctor : public GestureReceivedFunctor
{
- UnstageActorFunctor( SignalData& data, GestureState& stateToUnstage, Integration::Scene scene )
- : GestureReceivedFunctor( data ),
- stateToUnstage( stateToUnstage ),
- scene( scene )
+ UnstageActorFunctor(SignalData& data, GestureState& stateToUnstage, Integration::Scene scene)
+ : GestureReceivedFunctor(data),
+ stateToUnstage(stateToUnstage),
+ scene(scene)
{
}
- void operator()( Actor actor, const LongPressGesture& longPress )
+ void operator()(Actor actor, const LongPressGesture& longPress)
{
- GestureReceivedFunctor::operator()( actor, longPress );
+ GestureReceivedFunctor::operator()(actor, longPress);
- if ( longPress.GetState() == stateToUnstage )
+ if(longPress.GetState() == stateToUnstage)
{
- scene.Remove( actor );
+ scene.Remove(actor);
}
}
- GestureState& stateToUnstage;
+ GestureState& stateToUnstage;
Integration::Scene scene;
};
{
//For line coverage
unsigned int points = touch.GetPointCount();
- if( points > 0)
+ if(points > 0)
{
tet_printf("Touch Point state = %d\n", touch.GetState(0));
}
}
};
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
-
// Positive test case for a method
int UtcDaliLongPressGestureDetectorConstructorP(void)
{
{
TestApplication application;
- LongPressGestureDetector detector = LongPressGestureDetector::New();;
+ LongPressGestureDetector detector = LongPressGestureDetector::New();
+ ;
- LongPressGestureDetector copy( detector );
- DALI_TEST_CHECK( detector );
+ LongPressGestureDetector copy(detector);
+ DALI_TEST_CHECK(detector);
END_TEST;
}
TestApplication application;
LongPressGestureDetector detector;
- detector = LongPressGestureDetector::New();;
+ detector = LongPressGestureDetector::New();
+ ;
LongPressGestureDetector copy;
copy = detector;
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(detector);
- DALI_TEST_CHECK( detector == copy );
+ DALI_TEST_CHECK(detector == copy);
END_TEST;
}
// Attach an actor and emit a touch event on the actor to ensure complete line coverage
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
actor.TouchedSignal().Connect(&application, touchFunctor);
Integration::TouchEvent touchEvent(1);
- Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 20.0f, 20.0f ) );
+ Integration::Point point;
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(20.0f, 20.0f));
touchEvent.AddPoint(point);
application.ProcessEvent(touchEvent);
LongPressGestureDetector detector2 = LongPressGestureDetector::DownCast(object);
DALI_TEST_CHECK(detector2);
- LongPressGestureDetector detector3 = DownCast< LongPressGestureDetector >(object);
+ LongPressGestureDetector detector3 = DownCast<LongPressGestureDetector>(object);
DALI_TEST_CHECK(detector3);
- BaseHandle unInitializedObject;
+ BaseHandle unInitializedObject;
LongPressGestureDetector detector4 = LongPressGestureDetector::DownCast(unInitializedObject);
DALI_TEST_CHECK(!detector4);
- LongPressGestureDetector detector5 = DownCast< LongPressGestureDetector >(unInitializedObject);
+ LongPressGestureDetector detector5 = DownCast<LongPressGestureDetector>(unInitializedObject);
DALI_TEST_CHECK(!detector5);
- GestureDetector detector6 = LongPressGestureDetector::New();
+ GestureDetector detector6 = LongPressGestureDetector::New();
LongPressGestureDetector detector7 = LongPressGestureDetector::DownCast(detector6);
DALI_TEST_CHECK(detector7);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do a long press outside actor's area
- TestGenerateLongPress( application, 112.0f, 112.0f );
- TestEndLongPress( application, 112.0f, 112.0f);
+ TestGenerateLongPress(application, 112.0f, 112.0f);
+ TestEndLongPress(application, 112.0f, 112.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do a long press inside actor's area
- TestGenerateLongPress( application, 50.0f, 50.0f );
+ TestGenerateLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
- TestEndLongPress( application, 50.0f, 50.0f);
+ DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
+ TestEndLongPress(application, 50.0f, 50.0f);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start long press within the actor's area
- TestGenerateLongPress( application, 20.0f, 20.0f );
+ TestGenerateLongPress(application, 20.0f, 20.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(20.0f, 20.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
- TestEndLongPress( application, 20.0f, 20.0f);
+ DALI_TEST_EQUALS(Vector2(20.0f, 20.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
+ TestEndLongPress(application, 20.0f, 20.0f);
// repeat the long press within the actor's area - we should still receive the signal
data.Reset();
- TestGenerateLongPress( application, 50.0f, 50.0f );
+ TestGenerateLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
- TestEndLongPress( application, 50.0f, 50.0f);
+ DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
+ TestEndLongPress(application, 50.0f, 50.0f);
// Detach actor
detector.DetachAll();
// Ensure we are no longer signalled
data.Reset();
- TestGenerateLongPress( application, 20.0f, 20.0f );
+ TestGenerateLongPress(application, 20.0f, 20.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- TestEndLongPress( application, 50.0f, 50.0f);
+ TestEndLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
// Actor lifetime is scoped
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
// Start long press within the actor's area
- TestGenerateLongPress( application, 20.0f, 20.0f );
+ TestGenerateLongPress(application, 20.0f, 20.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Remove the actor from stage and reset the data
// Actor should now have been destroyed
data.Reset();
- TestEndLongPress( application, 20.0f, 20.0f);
+ TestEndLongPress(application, 20.0f, 20.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion( Dali::Degree(90.0f), Vector3::ZAXIS ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do a long press
- TestGenerateLongPress( application, 5.0f, 5.0f );
- TestEndLongPress( application, 5.0f, 5.0f);
+ TestGenerateLongPress(application, 5.0f, 5.0f);
+ TestEndLongPress(application, 5.0f, 5.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
// Rotate actor again and render
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do another long press, should still receive event
data.Reset();
- TestGenerateLongPress( application, 5.0f, 5.0f );
- TestEndLongPress( application, 5.0f, 5.0f);
+ TestGenerateLongPress(application, 5.0f, 5.0f);
+ TestEndLongPress(application, 5.0f, 5.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
// Rotate actor again and render
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::YAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::YAXIS));
application.SendNotification();
application.Render();
// Do a long press, inside where the actor used to be, Should not receive the event
data.Reset();
- TestGenerateLongPress( application, 70.0f, 70.0f );
- TestEndLongPress( application, 70.0f, 70.0f);
+ TestGenerateLongPress(application, 70.0f, 70.0f);
+ TestEndLongPress(application, 70.0f, 70.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
// Set child to completely cover parent.
// Change rotation of child to be different from parent so that we can check if our local coordinate
// conversion of the parent actor is correct.
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- child.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
parent.Add(child);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do long press - hits child area but parent should still receive it
- TestGenerateLongPress( application, 50.0f, 50.0f );
- TestEndLongPress( application, 50.0f, 50.0f);
+ TestGenerateLongPress(application, 50.0f, 50.0f);
+ TestEndLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, parent == data.pressedActor, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.GetScreenPoint(), 0.01f, TEST_LOCATION);
// Do an entire long press, only check finished value
data.Reset();
- TestGenerateLongPress( application, 51.0f, 51.0f );
- TestEndLongPress( application, 51.0f, 51.0f);
+ TestGenerateLongPress(application, 51.0f, 51.0f);
+ TestEndLongPress(application, 51.0f, 51.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, child == data.pressedActor, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(51.0f, 51.0f), data.receivedGesture.GetScreenPoint(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor first = Actor::New();
- first.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- first.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(first);
Actor second = Actor::New();
- second.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- second.SetProperty( Actor::Property::POSITION_X, 100.0f);
- second.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ second.SetProperty(Actor::Property::POSITION_X, 100.0f);
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(second);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// LongPress within second actor's area
- TestGenerateLongPress( application, 120.0f, 10.0f );
- TestEndLongPress( application, 120.0f, 10.0f);
+ TestGenerateLongPress(application, 120.0f, 10.0f);
+ TestEndLongPress(application, 120.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.pressedActor, TEST_LOCATION);
// LongPress within first actor's area
data.Reset();
- TestGenerateLongPress( application, 20.0f, 10.0f );
- TestEndLongPress( application, 20.0f, 10.0f);
+ TestGenerateLongPress(application, 20.0f, 10.0f);
+ TestEndLongPress(application, 20.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, first == data.pressedActor, TEST_LOCATION);
// second actor shouldn't receive event
data.Reset();
- TestGenerateLongPress( application, 120.0f, 10.0f );
- TestEndLongPress( application, 120.0f, 10.0f);
+ TestGenerateLongPress(application, 120.0f, 10.0f);
+ TestEndLongPress(application, 120.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// first actor should continue receiving event
data.Reset();
- TestGenerateLongPress( application, 20.0f, 10.0f );
- TestEndLongPress( application, 20.0f, 10.0f);
+ TestGenerateLongPress(application, 20.0f, 10.0f);
+ TestEndLongPress(application, 20.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// LongPress in actor's area
- TestGenerateLongPress( application, 50.0f, 10.0f );
- TestEndLongPress( application, 50.0f, 10.0f);
+ TestGenerateLongPress(application, 50.0f, 10.0f);
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Actor becomes invisible - actor should not receive the next long press
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// Render and notify
application.SendNotification();
// LongPress in the same area, shouldn't receive event
data.Reset();
- TestGenerateLongPress( application, 50.0f, 10.0f );
- TestEndLongPress( application, 50.0f, 10.0f);
+ TestGenerateLongPress(application, 50.0f, 10.0f);
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to one detector
- SignalData firstData;
- GestureReceivedFunctor firstFunctor(firstData);
+ SignalData firstData;
+ GestureReceivedFunctor firstFunctor(firstData);
LongPressGestureDetector firstDetector = LongPressGestureDetector::New();
firstDetector.Attach(actor);
firstDetector.DetectedSignal().Connect(&application, firstFunctor);
// Attach actor to another detector
- SignalData secondData;
- GestureReceivedFunctor secondFunctor(secondData);
+ SignalData secondData;
+ GestureReceivedFunctor secondFunctor(secondData);
LongPressGestureDetector secondDetector = LongPressGestureDetector::New();
secondDetector.Attach(actor);
secondDetector.DetectedSignal().Connect(&application, secondFunctor);
// LongPress in actor's area - both detector's functors should be called
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// LongPress possible in actor's area.
- TestStartLongPress( application, 50.0f, 10.0f );
+ TestStartLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Move actor somewhere else
- actor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
// Render and notify
application.SendNotification();
application.Render();
// Emit Started event, we should not receive the long press.
- TestTriggerLongPress( application );
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestTriggerLongPress(application);
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// LongPress possible in empty area.
- TestStartLongPress( application, 50.0f, 10.0f );
+ TestStartLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Move actor in to the long press position.
- actor.SetProperty( Actor::Property::POSITION, Vector2( 0.0f, 0.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
// Render and notify
application.SendNotification();
application.Render();
// Emit STARTED event, we should not receive the long press.
- TestTriggerLongPress( application );
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestTriggerLongPress(application);
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Normal long press in actor's area for completeness.
- TestGenerateLongPress( application, 50.0f, 10.0f );
- TestEndLongPress( application, 50.0f, 10.0f);
+ TestGenerateLongPress(application, 50.0f, 10.0f);
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Send a possible followed by a cancel, we should not be signalled
- TestStartLongPress( application, 50.0f, 10.0f );
+ TestStartLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- TestMovePan( application, Vector2( 50.0f, 10.0f ) );
+ TestMovePan(application, Vector2(50.0f, 10.0f));
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit initial signal
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
detector.Detach(actor);
// Emit FINISHED, no signal
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit signals
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Render and notify
stateToUnstage = GestureState::FINISHED;
// Emit signals
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- tet_result( TET_PASS ); // If we get here then we have handled actor stage removal gracefully.
+ tet_result(TET_PASS); // If we get here then we have handled actor stage removal gracefully.
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Create and add a second actor so that GestureDetector destruction does not come into play.
- Actor dummyActor( Actor::New() );
- dummyActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- dummyActor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- dummyActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ Actor dummyActor(Actor::New());
+ dummyActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(dummyActor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
detector.Attach(dummyActor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Here we are testing a STARTED actor which is removed in the STARTED callback, but then added back
// before we get a finished state. As we were removed from the stage, even if we're at the same
// position, we should still not be signalled.
// Emit signals
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Here we delete an actor in started, we should not receive any subsequent signalling.
// Emit signals
- TestGenerateLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- SignalData data;
- GestureReceivedFunctor functor(data);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Add a layer to overlap the actor
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer );
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer);
layer.RaiseToTop();
// Render and notify
application.Render();
// Emit signals, should receive
- TestGenerateLongPress( application, 50.0f, 50.0f );
- TestEndLongPress( application, 50.0f, 50.0f );
+ TestGenerateLongPress(application, 50.0f, 50.0f);
+ TestEndLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Set layer to consume all touch
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
// Render and notify
application.SendNotification();
application.Render();
// Emit the same signals again, should not receive
- TestGenerateLongPress( application, 50.0f, 50.0f );
- TestEndLongPress( application, 50.0f, 50.0f );
+ TestGenerateLongPress(application, 50.0f, 50.0f);
+ TestEndLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
const uint32_t kMinumumHolding1 = 5000;
const uint32_t kMinumumHolding2 = 3000;
- Integration::SetLongPressMinimumHoldingTime( kMinumumHolding1 );
+ Integration::SetLongPressMinimumHoldingTime(kMinumumHolding1);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.Attach(actor);
detector.DetectedSignal().Connect(&application, functor);
- DALI_TEST_EQUALS( DevelLongPressGestureDetector::GetMinimumHoldingTime( detector ), kMinumumHolding1, TEST_LOCATION );
+ DALI_TEST_EQUALS(DevelLongPressGestureDetector::GetMinimumHoldingTime(detector), kMinumumHolding1, TEST_LOCATION);
- Integration::SetLongPressMinimumHoldingTime( kMinumumHolding2 );
- DALI_TEST_EQUALS( DevelLongPressGestureDetector::GetMinimumHoldingTime( detector ), kMinumumHolding2, TEST_LOCATION );
+ Integration::SetLongPressMinimumHoldingTime(kMinumumHolding2);
+ DALI_TEST_EQUALS(DevelLongPressGestureDetector::GetMinimumHoldingTime(detector), kMinumumHolding2, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
- bool consume = false;
+ bool consume = false;
TouchEventFunctorConsumeSetter touchFunctor(consume);
- actor.TouchedSignal().Connect(&application,touchFunctor);
+ actor.TouchedSignal().Connect(&application, touchFunctor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
LongPressGestureDetector detector = LongPressGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start gesture within the actor's area, we should receive the gesture as the touch is NOT being consumed
- TestGenerateLongPress( application, 50.0f, 50.0f );
+ TestGenerateLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndLongPress(application, 50.0f,50.0f);
+ TestEndLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Another gesture in the same location, this time we will not receive it as touch is being consumed
consume = true;
- TestGenerateLongPress( application, 50.0f, 50.0f );
+ TestGenerateLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndLongPress(application, 50.0f,50.0f);
+ TestEndLongPress(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- LongPressGestureDetector detector = LongPressGestureDetector::New();
- bool functorCalled = false;
- detector.Attach( actor );
+ LongPressGestureDetector detector = LongPressGestureDetector::New();
+ bool functorCalled = false;
+ detector.Attach(actor);
detector.DetectedSignal().Connect(
- &application,
- [&detector, &functorCalled](Actor actor, const LongPressGesture& gesture)
+ &application,
+ [&detector, &functorCalled](Actor actor, const LongPressGesture& gesture) {
+ if(gesture.GetState() == GestureState::FINISHED)
{
- if( gesture.GetState() == GestureState::FINISHED )
- {
- detector.Detach(actor);
- functorCalled = true;
- }
- });
+ detector.Detach(actor);
+ functorCalled = true;
+ }
+ });
// Render and notify
application.SendNotification();
// Try the gesture, should not crash
try
{
- TestGenerateLongPress( application, 50.0f, 10.0f );
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
+ TestEndLongPress(application, 50.0f, 10.0f);
- DALI_TEST_CHECK( true ); // No crash, test has passed
+ DALI_TEST_CHECK(true); // No crash, test has passed
DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
}
catch(...)
{
- DALI_TEST_CHECK( false ); // If we crash, the test has failed
+ DALI_TEST_CHECK(false); // If we crash, the test has failed
}
END_TEST;
}
-
-
*
*/
-#include <iostream>
-#include <thread>
-#include <chrono>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <chrono>
+#include <iostream>
+#include <thread>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
struct SignalData
{
SignalData()
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pressedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
LongPressGesture receivedGesture;
- Actor pressedActor;
+ Actor pressedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const LongPressGesture& pan)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = pan;
- signalData.pressedActor = actor;
+ signalData.pressedActor = actor;
}
void operator()()
SignalData& signalData;
};
-
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
+ Integration::Point point;
+ point.SetState(state);
point.SetDeviceId(4);
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-Integration::TouchEvent GenerateDoubleTouch( PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time )
+Integration::TouchEvent GenerateDoubleTouch(PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( stateA );
+ Integration::Point point;
+ point.SetState(stateA);
point.SetDeviceId(4);
- point.SetScreenPosition( screenPositionA );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
- point.SetScreenPosition( screenPositionB );
- point.SetState( stateB);
+ point.SetScreenPosition(screenPositionA);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
+ point.SetScreenPosition(screenPositionB);
+ point.SetState(stateB);
point.SetDeviceId(7);
- touchEvent.points.push_back( point );
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
-
int UtcDaliLongPressGestureRecognizerBasicNoAction(void)
{
TestApplication application;
LongPressGestureDetector detector = LongPressGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
LongPressGestureDetector detector = LongPressGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
application.GetPlatform().TriggerTimer();
LongPressGestureDetector detector = LongPressGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
application.SendNotification();
LongPressGestureDetector detector = LongPressGestureDetector::New();
- detector.SetTouchesRequired(2,2);
+ detector.SetTouchesRequired(2, 2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
// There should be no function to call
application.GetPlatform().TriggerTimer();
LongPressGestureDetector detector = LongPressGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 151 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 151));
// There should be no function to call as the double touch should have cancelled it
application.GetPlatform().TriggerTimer();
LongPressGestureDetector detector = LongPressGestureDetector::New();
- detector.SetTouchesRequired(2,2);
+ detector.SetTouchesRequired(2, 2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 0.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 151 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 10.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 153 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 155 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 60.0f ), 157 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 50.0f ), 159 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::STATIONARY, Vector2( 20.0f, 40.0f ), PointState::UP, Vector2( 20.0f, 50.0f ), 160 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 40.0f ), 161 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 0.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 151));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 10.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 153));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 155));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 60.0f), 157));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 50.0f), 159));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::STATIONARY, Vector2(20.0f, 40.0f), PointState::UP, Vector2(20.0f, 50.0f), 160));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 40.0f), 161));
application.GetPlatform().TriggerTimer();
LongPressGestureDetector detector = LongPressGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
detector.Attach(actor);
- detector.SetTouchesRequired(2,2); // Set after we've attached forcing us to change things internally
+ detector.SetTouchesRequired(2, 2); // Set after we've attached forcing us to change things internally
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 40.0f ), 140 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 40.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 40.0f), 140));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 40.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
application.GetPlatform().TriggerTimer();
- application.ProcessEvent( GenerateDoubleTouch( PointState::STATIONARY, Vector2( 20.0f, 20.0f ), PointState::UP, Vector2( 20.0f, 90.0f ), 760 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 761 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::STATIONARY, Vector2(20.0f, 20.0f), PointState::UP, Vector2(20.0f, 90.0f), 760));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 761));
application.SendNotification();
{
TestApplication application;
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add(actor);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
- Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor2.SetProperty( Actor::Property::POSITION_X, 100.0f);
- application.GetScene().Add(actor2);
+ Actor actor2 = Actor::New();
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor2.SetProperty(Actor::Property::POSITION_X, 100.0f);
+ application.GetScene().Add(actor2);
- // Render and notify
- application.SendNotification();
- application.Render();
+ // Render and notify
+ application.SendNotification();
+ application.Render();
- LongPressGestureDetector detector = LongPressGestureDetector::New();
- detector.Attach(actor);
+ LongPressGestureDetector detector = LongPressGestureDetector::New();
+ detector.Attach(actor);
- LongPressGestureDetector detector2 = LongPressGestureDetector::New(2);
- detector2.Attach(actor2);
+ LongPressGestureDetector detector2 = LongPressGestureDetector::New(2);
+ detector2.Attach(actor2);
- SignalData data;
- GestureReceivedFunctor functor(data);
- detector.DetectedSignal().Connect(&application, functor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- SignalData data2;
- GestureReceivedFunctor functor2(data2);
- detector2.DetectedSignal().Connect(&application, functor2);
+ SignalData data2;
+ GestureReceivedFunctor functor2(data2);
+ detector2.DetectedSignal().Connect(&application, functor2);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.GetPlatform().TriggerTimer();
+ application.GetPlatform().TriggerTimer();
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 700 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 700));
- application.SendNotification();
+ application.SendNotification();
- DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- DALI_TEST_EQUALS(true, actor == data.pressedActor, TEST_LOCATION);
- data.Reset();
- DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, actor == data.pressedActor, TEST_LOCATION);
+ data.Reset();
+ DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 120.0f, 40.0f ), 800 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 120.0f, 40.0f ), PointState::DOWN, Vector2( 120.0f, 90.0f ), 805 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(120.0f, 40.0f), 800));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(120.0f, 40.0f), PointState::DOWN, Vector2(120.0f, 90.0f), 805));
- application.GetPlatform().TriggerTimer();
+ application.GetPlatform().TriggerTimer();
- application.SendNotification();
+ application.SendNotification();
- DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- DALI_TEST_EQUALS(true, data2.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, data2.functorCalled, TEST_LOCATION);
- END_TEST;
+ END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
try
{
- NextPowerOfTwo( (1u << (sizeof(unsigned) * 8 - 1)) + 1);
+ NextPowerOfTwo((1u << (sizeof(unsigned) * 8 - 1)) + 1);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "Return type cannot represent the next power of two greater than the argument.", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "Return type cannot represent the next power of two greater than the argument.", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
DALI_TEST_EQUALS(Clamp(0, -10, 10), 0, TEST_LOCATION);
DALI_TEST_EQUALS(Clamp(20, 0, 10), 10, TEST_LOCATION);
- float value=-10.0f, min=-2.0f, max=4.0f;
+ float value = -10.0f, min = -2.0f, max = 4.0f;
ClampInPlace(value, min, max);
DALI_TEST_EQUALS(value, min, 0.001, TEST_LOCATION);
{
Dali::TestApplication testApp;
- float value=-10.0f, min=-2.0f, max=4.0f;
+ float value = -10.0f, min = -2.0f, max = 4.0f;
ClampInPlace(value, min, max);
DALI_TEST_EQUALS(value, min, 0.001, TEST_LOCATION);
{
Dali::TestApplication testApp;
- float offset=0.0f, low=-2.0f, high=4.0f;
+ float offset = 0.0f, low = -2.0f, high = 4.0f;
DALI_TEST_EQUALS(Lerp(offset, low, high), low, 0.001, TEST_LOCATION);
offset = 1.0f;
DALI_TEST_EQUALS(Lerp(offset, low, high), high, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 0.099f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(0.099f, 0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(0.99f, 0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 0.099f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(0.099f, 0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(0.99f, 0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(0.99f, 0.98f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(1.05f, 0.99f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(1.99f, 1.05f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(2.0f, 1.99f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 2.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(1.0f, 3.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(2.0f, 1.99f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(0.05f, 2.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(1.0f, 3.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(9.99f, 0.5f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(9.99f, 1.5f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(9.99f, 9.99f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(1e07f, 0.99e09f), Dali::Math::MACHINE_EPSILON_10000, TEST_LOCATION);
-
DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -0.099f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-0.099f, - 0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-0.99f, -0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -0.099f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-0.099f, -0.02f), Dali::Math::MACHINE_EPSILON_0, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-0.99f, -0.5f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-0.99f, -0.98f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-1.05f, -0.99f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-1.99f, -1.05f), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-2.0f, - 1.99f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -2.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
- DALI_TEST_EQUALS(GetRangedEpsilon(-1.0f, - 3.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-2.0f, -1.99f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-0.05f, -2.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(GetRangedEpsilon(-1.0f, -3.0f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-9.99f, -0.5f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-9.99f, -1.5f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-9.99f, -9.99f), Dali::Math::MACHINE_EPSILON_10, TEST_LOCATION);
DALI_TEST_EQUALS(GetRangedEpsilon(-1e07f, -0.99e09f), Dali::Math::MACHINE_EPSILON_10000, TEST_LOCATION);
-
END_TEST;
}
int UtcDaliMathUtilsEqualsZeroP(void)
{
- float v=0.0f;
+ float v = 0.0f;
DALI_TEST_CHECK(EqualsZero(v));
- v = Math::PI;
+ v = Math::PI;
v -= (Math::PI_2 * 2.0f);
DALI_TEST_CHECK(EqualsZero(v));
int UtcDaliMathUtilsEquals01P(void)
{
- float w=100.0f;
- float x=w+1e-8f;
- DALI_TEST_CHECK( Equals(w, x, GetRangedEpsilon( w, x )) );
+ float w = 100.0f;
+ float x = w + 1e-8f;
+ DALI_TEST_CHECK(Equals(w, x, GetRangedEpsilon(w, x)));
END_TEST;
}
int UtcDaliMathUtilsEquals02P(void)
{
- float w=100.0f;
- float x=w+1e-8f;
- DALI_TEST_CHECK( Equals(w, x) );
+ float w = 100.0f;
+ float x = w + 1e-8f;
+ DALI_TEST_CHECK(Equals(w, x));
END_TEST;
}
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
#include <iostream>
#include <sstream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-
using namespace Dali;
-
void utc_dali_matrix_startup(void)
{
test_return_value = TET_UNDEF;
test_return_value = TET_PASS;
}
-
int UtcDaliMatrixConstructor01P(void)
{
// State of memory cannot be guaranteed, so use
memset(buffer, 1, sizeof(Matrix));
- Matrix* m2 = new(&buffer) Matrix(false);
- bool initialisation_occured = false;
+ Matrix* m2 = new(&buffer) Matrix(false);
+ bool initialisation_occured = false;
{
float* els = m2->AsFloat();
- for(size_t idx=0; idx<16; ++idx, ++els)
+ for(size_t idx = 0; idx < 16; ++idx, ++els)
{
if(*els == 0.0f)
initialisation_occured = true;
int UtcDaliMatrixConstructor02P(void)
{
- float r[] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
+ float r[] = {1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
Matrix m(r);
- float* els = m.AsFloat();
- float* init = r;
- bool initialised = true;
- for(size_t idx=0; idx<16; ++idx, ++els, ++init)
+ float* els = m.AsFloat();
+ float* init = r;
+ bool initialised = true;
+ for(size_t idx = 0; idx < 16; ++idx, ++els, ++init)
{
if(*els != *init)
initialised = false;
int UtcDaliMatrixConstructor03P(void)
{
- float r[] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
+ float r[] = {1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
Matrix ma(r);
Matrix mb(ma);
- float* els = ma.AsFloat();
- float* init = mb.AsFloat();
- bool initialised = true;
- for(size_t idx=0; idx<16; ++idx, ++els, ++init)
+ float* els = ma.AsFloat();
+ float* init = mb.AsFloat();
+ bool initialised = true;
+ for(size_t idx = 0; idx < 16; ++idx, ++els, ++init)
{
if(*els != *init)
initialised = false;
int UtcDaliMatrixConstructor04P(void)
{
Quaternion q(Quaternion::IDENTITY);
- Matrix m(q);
+ Matrix m(q);
DALI_TEST_EQUALS(Matrix(Matrix::IDENTITY), m, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliMatrixCopyConstructor(void)
{
- Matrix m0( Matrix::IDENTITY );
- Matrix m1( m0 );
+ Matrix m0(Matrix::IDENTITY);
+ Matrix m1(m0);
DALI_TEST_EQUALS(m1, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliMatrixMoveConstructor(void)
{
- Matrix m0( Matrix::IDENTITY );
- Matrix m1 = std::move( m0 );
+ Matrix m0(Matrix::IDENTITY);
+ Matrix m1 = std::move(m0);
DALI_TEST_EQUALS(m1, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliMatrixCopyAssignment(void)
{
- Matrix m0( Matrix::IDENTITY );
+ Matrix m0(Matrix::IDENTITY);
Matrix m1;
m1 = m0;
DALI_TEST_EQUALS(m1, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
int UtcDaliMatrixMoveAssignment(void)
{
- Matrix m0( Matrix::IDENTITY );
+ Matrix m0(Matrix::IDENTITY);
Matrix m1;
- m1 = std::move( m0 );
+ m1 = std::move(m0);
DALI_TEST_EQUALS(m1, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliMatrixSetIdentityP(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
m.SetIdentity();
int UtcDaliMatrixSetIdentityAndScaleP(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
m.SetIdentityAndScale(Vector3(4.0f, 4.0f, 4.0f));
- float els2[] = { 4.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 4.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 4.0f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f };
+ float els2[] = {4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
Matrix r(els2);
DALI_TEST_EQUALS(m, r, 0.001f, TEST_LOCATION);
int UtcDaliMatrixInvertTransformP(void)
{
- for (int i=0;i<1000;++i)
+ for(int i = 0; i < 1000; ++i)
{
- float f = i;
- Vector3 axis(cosf(f*0.001f), cosf(f*0.02f), cosf(f*0.03f));
+ float f = i;
+ Vector3 axis(cosf(f * 0.001f), cosf(f * 0.02f), cosf(f * 0.03f));
axis.Normalize();
- Vector3 center(f, cosf(f) * 100.0f, cosf(f*0.5f) * 50.0f);
+ Vector3 center(f, cosf(f) * 100.0f, cosf(f * 0.5f) * 50.0f);
Matrix m0;
m0.SetIdentity();
- m0.SetTransformComponents( Vector3::ONE, Quaternion(Radian(1.0f), axis), center );
+ m0.SetTransformComponents(Vector3::ONE, Quaternion(Radian(1.0f), axis), center);
Matrix m1;
m0.InvertTransform(m1);
- Matrix m2( false );
- Matrix::Multiply( m2, m0, m1 );
+ Matrix m2(false);
+ Matrix::Multiply(m2, m0, m1);
DALI_TEST_EQUALS(m2, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
}
int UtcDaliMatrixInvertTransformN(void)
{
- std::string exceptionString( "EqualsZero( mMatrix[3] ) && EqualsZero( mMatrix[7] ) && EqualsZero( mMatrix[11] ) && Equals( mMatrix[15], 1.0f" );
+ std::string exceptionString("EqualsZero(mMatrix[3]) && EqualsZero(mMatrix[7]) && EqualsZero(mMatrix[11]) && Equals(mMatrix[15], 1.0f");
try
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
Matrix it;
m.InvertTransform(it);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, exceptionString, TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, exceptionString, TEST_LOCATION);
}
try
{
- float els[] = { 0.0f, 1.0f, 2.0f, 0.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 0.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
Matrix it;
m.InvertTransform(it);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, exceptionString, TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, exceptionString, TEST_LOCATION);
}
try
{
- float els[] = { 0.0f, 1.0f, 2.0f, 0.0f,
- 4.0f, 5.0f, 6.0f, 0.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 0.0f, 4.0f, 5.0f, 6.0f, 0.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
Matrix it;
m.InvertTransform(it);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, exceptionString, TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, exceptionString, TEST_LOCATION);
}
try
{
- float els[] = { 0.0f, 1.0f, 2.0f, 0.0f,
- 4.0f, 5.0f, 6.0f, 0.0f,
- 8.0f, 9.0f, 10.0f, 0.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 0.0f, 4.0f, 5.0f, 6.0f, 0.0f, 8.0f, 9.0f, 10.0f, 0.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
Matrix it;
m.InvertTransform(it);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, exceptionString, TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, exceptionString, TEST_LOCATION);
}
END_TEST;
}
{
// We're going to invert a whole load of different matrices to make sure we don't
// fail on particular orientations.
- for (int i=0;i<1000;++i)
+ for(int i = 0; i < 1000; ++i)
{
- float f = i;
- Vector3 axis(cosf(f*0.001f), cosf(f*0.02f), cosf(f*0.03f));
+ float f = i;
+ Vector3 axis(cosf(f * 0.001f), cosf(f * 0.02f), cosf(f * 0.03f));
axis.Normalize();
- Vector3 center(f, cosf(f) * 100.0f, cosf(f*0.5f) * 50.0f);
+ Vector3 center(f, cosf(f) * 100.0f, cosf(f * 0.5f) * 50.0f);
Matrix m0;
m0.SetIdentity();
- m0.SetTransformComponents( Vector3::ONE, Quaternion(Radian(1.0f), axis), center );
+ m0.SetTransformComponents(Vector3::ONE, Quaternion(Radian(1.0f), axis), center);
Matrix m1(m0);
m1.Invert();
- Matrix m2( false );
- Matrix::Multiply( m2, m0, m1 );
+ Matrix m2(false);
+ Matrix::Multiply(m2, m0, m1);
DALI_TEST_EQUALS(m2, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
- m1.Invert(); // doube invert - should be back to m0
+ m1.Invert(); // doube invert - should be back to m0
DALI_TEST_EQUALS(m0, m1, 0.001f, TEST_LOCATION);
}
int UtcDaliMatrixTransposeP(void)
{
float floats[] =
- { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f
- };
+ {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(floats);
m.Transpose();
bool success = true;
- for (int x=0;x<4;++x)
+ for(int x = 0; x < 4; ++x)
{
- for (int y=0;y<4;++y)
+ for(int y = 0; y < 4; ++y)
{
- success &= (m.AsFloat()[x+y*4] == floats[x*4+y]);
+ success &= (m.AsFloat()[x + y * 4] == floats[x * 4 + y]);
}
}
int UtcDaliMatrixGetXAxisP(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
- DALI_TEST_CHECK(m.GetXAxis() == Vector3(0.0f, 1.0f, 2.0f));
+ DALI_TEST_CHECK(m.GetXAxis() == Vector3(0.0f, 1.0f, 2.0f));
END_TEST;
}
int UtcDaliMatrixGetYAxisP(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
- DALI_TEST_CHECK(m.GetYAxis() == Vector3(4.0f, 5.0f, 6.0f));
+ DALI_TEST_CHECK(m.GetYAxis() == Vector3(4.0f, 5.0f, 6.0f));
END_TEST;
}
int UtcDaliMatrixGetZAxisP(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
- DALI_TEST_CHECK(m.GetZAxis() == Vector3(8.0f, 9.0f, 10.0f));
+ DALI_TEST_CHECK(m.GetZAxis() == Vector3(8.0f, 9.0f, 10.0f));
END_TEST;
}
int UtcDaliMatrixSetXAxisP(void)
{
- Matrix m;
+ Matrix m;
Vector3 v(2.0f, 3.0f, 4.0f);
m.SetXAxis(v);
int UtcDaliMatrixSetYAxisP(void)
{
- Matrix m;
+ Matrix m;
Vector3 v(2.0f, 3.0f, 4.0f);
m.SetYAxis(v);
int UtcDaliMatrixSetZAxisP(void)
{
- Matrix m;
+ Matrix m;
Vector3 v(2.0f, 3.0f, 4.0f);
m.SetZAxis(v);
int UtcDaliMatrixGetTranslationP(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
DALI_TEST_EQUALS(m.GetTranslation(), Vector4(12.0f, 13.0f, 14.0f, 15.0f), TEST_LOCATION);
int UtcDaliMatrixGetTranslation3P(void)
{
- float els[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f };
+ float els[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m(els);
DALI_TEST_EQUALS(m.GetTranslation3(), Vector3(12.0f, 13.0f, 14.0f), TEST_LOCATION);
int UtcDaliMatrixSetTranslationP(void)
{
- Matrix m;
+ Matrix m;
Vector4 v(2.0f, 3.0f, 4.0f, 5.0f);
m.SetTranslation(v);
int UtcDaliMatrixSetTranslation3P(void)
{
- Matrix m;
+ Matrix m;
Vector3 v(2.0f, 3.0f, 4.0f);
m.SetTranslation(v);
Matrix m;
m.SetIdentity();
- for (int i=0;i<1000;++i)
+ for(int i = 0; i < 1000; ++i)
{
- float f = i;
- Vector3 axis(cosf(f*0.001f), cosf(f*0.02f), cosf(f*0.03f));
+ float f = i;
+ Vector3 axis(cosf(f * 0.001f), cosf(f * 0.02f), cosf(f * 0.03f));
axis.Normalize();
- m.SetTransformComponents( Vector3::ONE, Quaternion(Radian(1.0f), axis), Vector3::ZERO );
+ m.SetTransformComponents(Vector3::ONE, Quaternion(Radian(1.0f), axis), Vector3::ZERO);
m.OrthoNormalize();
}
int UtcDaliMatrixOrthoNormalize1P(void)
{
// OrthoNormalize is not flipping the axes and is maintaining the translation
- for (int i=0;i<1000;++i)
+ for(int i = 0; i < 1000; ++i)
{
- float f = i;
- Vector3 axis(cosf(f*0.001f), cosf(f*0.02f), cosf(f*0.03f));
+ float f = i;
+ Vector3 axis(cosf(f * 0.001f), cosf(f * 0.02f), cosf(f * 0.03f));
axis.Normalize();
Vector3 center(10.0f, 15.0f, 5.0f);
Matrix m0;
m0.SetIdentity();
- m0.SetTransformComponents( Vector3::ONE, Quaternion(Radian(1.0f), axis), center );
+ m0.SetTransformComponents(Vector3::ONE, Quaternion(Radian(1.0f), axis), center);
Matrix m1(m0);
m1.OrthoNormalize();
int UtcDaliMatrixConstAsFloatP(void)
{
- float r[] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
+ float r[] = {1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
const Matrix m(r);
- const float* els = m.AsFloat();
- const float* init = r;
- bool initialised = true;
- for(size_t idx=0; idx<16; ++idx, ++els, ++init)
+ const float* els = m.AsFloat();
+ const float* init = r;
+ bool initialised = true;
+ for(size_t idx = 0; idx < 16; ++idx, ++els, ++init)
{
if(*els != *init)
initialised = false;
}
DALI_TEST_EQUALS(initialised, true, TEST_LOCATION);
-
END_TEST;
}
int UtcDaliMatrixAsFloatP(void)
{
- float r[] = { 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
+ float r[] = {1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f, 1.0f, 2.0f, 3.0f, 4.0f};
Matrix m(r);
- float* els = m.AsFloat();
- float* init = r;
- bool initialised = true;
- for(size_t idx=0; idx<16; ++idx, ++els, ++init)
+ float* els = m.AsFloat();
+ float* init = r;
+ bool initialised = true;
+ for(size_t idx = 0; idx < 16; ++idx, ++els, ++init)
{
if(*els != *init)
initialised = false;
}
DALI_TEST_EQUALS(initialised, true, TEST_LOCATION);
-
END_TEST;
}
{
Matrix m1 = Matrix::IDENTITY;
- float els[] = { 1.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 0.707f, 0.707f, 0.0f,
- 0.0f, -0.707f, 0.707f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f };
+ float els[] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.707f, 0.707f, 0.0f, 0.0f, -0.707f, 0.707f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
Matrix result(els);
Quaternion q(Radian(Degree(45.0f)), Vector3::XAXIS);
- Matrix m2(false);
+ Matrix m2(false);
Matrix::Multiply(m2, m1, q);
DALI_TEST_EQUALS(m2, result, 0.01f, TEST_LOCATION);
{
Vector4 v1(2.0f, 5.0f, 4.0f, 0.0f);
- float els[] = {2.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 3.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 4.0f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f };
+ float els[] = {2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
Matrix m1(els);
Vector4 v2 = m1 * v1;
{
TestApplication application;
- Vector3 position ( 30.f, 40.f, 50.f);
+ Vector3 position(30.f, 40.f, 50.f);
Matrix m1(false);
m1.SetIdentity();
m1.SetTranslation(-position);
Vector4 positionV4(position);
- positionV4.w=1.0f;
+ positionV4.w = 1.0f;
Vector4 output = m1 * positionV4;
output.w = 0.0f;
{
Matrix m1 = Matrix::IDENTITY;
- float els[] = { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+ float els[] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
Matrix r2(els);
DALI_TEST_EQUALS(m1 == r2, true, TEST_LOCATION);
- float *f = m1.AsFloat();
- for(size_t i=0; i<16; i++)
+ float* f = m1.AsFloat();
+ for(size_t i = 0; i < 16; i++)
{
- f[15-i] = 1.2f;
+ f[15 - i] = 1.2f;
DALI_TEST_EQUALS(m1 == r2, false, TEST_LOCATION);
}
END_TEST;
int UtcDaliMatrixOperatorNotEqualsP(void)
{
- Matrix m1 = Matrix::IDENTITY;
- float els[] = {2.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 3.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 4.0f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f };
+ Matrix m1 = Matrix::IDENTITY;
+ float els[] = {2.0f, 0.0f, 0.0f, 0.0f, 0.0f, 3.0f, 0.0f, 0.0f, 0.0f, 0.0f, 4.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
Matrix r1(els);
DALI_TEST_CHECK(m1 != r1);
int UtcDaliMatrixSetTransformComponents01P(void)
{
// Create an arbitrary vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
Vector3 vForward(x, y, z);
vForward.Normalize();
- for( float angle = 5.0f; angle <= 360.0f; angle += 15.0f)
+ for(float angle = 5.0f; angle <= 360.0f; angle += 15.0f)
{
Quaternion rotation1(Radian(Degree(angle)), vForward);
- Matrix m1(rotation1);
- Matrix result1(false);
+ Matrix m1(rotation1);
+ Matrix result1(false);
Vector3 vForward3(vForward.x, vForward.y, vForward.z);
- result1.SetTransformComponents( Vector3::ONE, Quaternion(Radian(Degree(angle)), vForward3), Vector3::ZERO );
+ result1.SetTransformComponents(Vector3::ONE, Quaternion(Radian(Degree(angle)), vForward3), Vector3::ZERO);
DALI_TEST_EQUALS(m1, result1, 0.001, TEST_LOCATION);
int UtcDaliMatrixSetInverseTransformComponent01P(void)
{
// Create an arbitrary vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
Vector3 vForward(x, y, z);
vForward.Normalize();
{
Quaternion rotation1(Quaternion::IDENTITY); // test no rotation branch
- Vector3 scale1(2.0f, 3.0f, 4.0f);
- Vector3 position1(1.0f, 2.0f, 3.0f);
+ Vector3 scale1(2.0f, 3.0f, 4.0f);
+ Vector3 position1(1.0f, 2.0f, 3.0f);
Matrix m1(false);
m1.SetTransformComponents(scale1, rotation1, position1);
int UtcDaliMatrixSetInverseTransformComponent02P(void)
{
// Create an arbitrary vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
Vector3 vForward(x, y, z);
vForward.Normalize();
- for( float angle = 5.0f; angle <= 360.0f; angle += 15.0f)
+ for(float angle = 5.0f; angle <= 360.0f; angle += 15.0f)
{
Quaternion rotation1(Radian(Degree(angle)), vForward);
- Matrix rotationMatrix(rotation1); // TEST RELIES ON THIS METHOD WORKING!!!
+ Matrix rotationMatrix(rotation1); // TEST RELIES ON THIS METHOD WORKING!!!
Vector3 position1(5.0f, -6.0f, 7.0f);
Matrix m1(false);
- m1.SetTransformComponents( Vector3::ONE, rotation1, position1 );
+ m1.SetTransformComponents(Vector3::ONE, rotation1, position1);
Matrix m2(false);
- m2.SetInverseTransformComponents( rotationMatrix.GetXAxis(),
- rotationMatrix.GetYAxis(),
- rotationMatrix.GetZAxis(),
- position1 );
+ m2.SetInverseTransformComponents(rotationMatrix.GetXAxis(),
+ rotationMatrix.GetYAxis(),
+ rotationMatrix.GetZAxis(),
+ position1);
Matrix result;
Matrix::Multiply(result, m1, m2);
int UtcDaliMatrixGetTransformComponents01P(void)
{
- Matrix m2(Matrix::IDENTITY.AsFloat());
- Vector3 pos2;
- Vector3 scale2;
+ Matrix m2(Matrix::IDENTITY.AsFloat());
+ Vector3 pos2;
+ Vector3 scale2;
Quaternion q2;
m2.GetTransformComponents(pos2, q2, scale2);
DALI_TEST_EQUALS(Vector3(0.0f, 0.0f, 0.0f), pos2, 0.001, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliMatrixGetTransformComponents02P(void)
{
// Create an arbitrary vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
Vector3 vForward(x, y, z);
vForward.Normalize();
- for( float angle = 5.0f; angle <= 360.0f; angle += 15.0f)
+ for(float angle = 5.0f; angle <= 360.0f; angle += 15.0f)
{
Quaternion rotation1(Radian(Degree(angle)), vForward);
- Vector3 scale1(2.0f, 3.0f, 4.0f);
- Vector3 position1(1.0f, 2.0f, 3.0f);
+ Vector3 scale1(2.0f, 3.0f, 4.0f);
+ Vector3 position1(1.0f, 2.0f, 3.0f);
Matrix m1(false);
m1.SetTransformComponents(scale1, rotation1, position1);
- Vector3 position2;
+ Vector3 position2;
Quaternion rotation2;
- Vector3 scale2;
+ Vector3 scale2;
m1.GetTransformComponents(position2, rotation2, scale2);
DALI_TEST_EQUALS(position1, position2, 0.001, TEST_LOCATION);
int UtcDaliMatrixGetTransformComponents03P(void)
{
- Matrix m2; // zero branch
- Vector3 pos2;
- Vector3 scale2;
+ Matrix m2; // zero branch
+ Vector3 pos2;
+ Vector3 scale2;
Quaternion q2;
m2.GetTransformComponents(pos2, q2, scale2);
DALI_TEST_EQUALS(Vector3(0.0f, 0.0f, 0.0f), pos2, 0.001, TEST_LOCATION);
std::string expectedOutput = "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+#include <iostream>
using namespace Dali;
namespace
{
-
Matrix3 m1(
- -18.6f, 1.88e-09f, -6.85e-09f,
- 0.0f,13.2f, 13.2f,
- -1.36e-08f,13.2f, -13.2f);
+ -18.6f, 1.88e-09f, -6.85e-09f, 0.0f, 13.2f, 13.2f, -1.36e-08f, 13.2f, -13.2f);
Matrix3 m2(
- -18.6f,6.91e-06f, 6.76e-06f,
- 8.04e-09f,13.2f, 13.2f,
- 3.01e-06f,13.2f, -13.2f);
+ -18.6f, 6.91e-06f, 6.76e-06f, 8.04e-09f, 13.2f, 13.2f, 3.01e-06f, 13.2f, -13.2f);
Matrix3 m3(
- 6.24f,-12.4f, -12.4f,
- -17.6f,-4.46f, -4.37f,
- -0.0641f,13.2f, -13.2f);
+ 6.24f, -12.4f, -12.4f, -17.6f, -4.46f, -4.37f, -0.0641f, 13.2f, -13.2f);
Matrix3 m4(
- -16.3f,6.42f, 6.38f,
- 9.05f,11.6f, 11.4f,
- -0.0371f,13.1f, -13.3f);
+ -16.3f, 6.42f, 6.38f, 9.05f, 11.6f, 11.4f, -0.0371f, 13.1f, -13.3f);
Matrix3 m5(
- -2.43f,13.2f, 12.9f,
- 18.5f,1.92f, 1.51f,
- -0.257f,13.0f, -13.4f);
+ -2.43f, 13.2f, 12.9f, 18.5f, 1.92f, 1.51f, -0.257f, 13.0f, -13.4f);
Matrix3 m6(
- -2.43f, -13.2f, -200.9f,
- 18.5f, 1.92f, 1.51f,
- 0.257f, 13.0f, 13.4f);
-
+ -2.43f, -13.2f, -200.9f, 18.5f, 1.92f, 1.51f, 0.257f, 13.0f, 13.4f);
Matrix3 i1(
- -0.05, -0.00, 0.00,
- -0.00, 0.04, 0.04,
- 0.00, 0.04, -0.04);
+ -0.05, -0.00, 0.00, -0.00, 0.04, 0.04, 0.00, 0.04, -0.04);
Matrix3 i2(
- -0.05, 0.00, -0.00,
- 0.00, 0.04, 0.04,
- 0.00, 0.04, -0.04);
+ -0.05, 0.00, -0.00, 0.00, 0.04, 0.04, 0.00, 0.04, -0.04);
Matrix3 i3(
- 0.02, -0.05, -0.00,
- -0.04, -0.01, 0.04,
- -0.04, -0.01, -0.04);
+ 0.02, -0.05, -0.00, -0.04, -0.01, 0.04, -0.04, -0.01, -0.04);
Matrix3 i4(
- -0.05, 0.03, -0.00,
- 0.02, 0.03, 0.04,
- 0.02, 0.03, -0.04);
+ -0.05, 0.03, -0.00, 0.02, 0.03, 0.04, 0.02, 0.03, -0.04);
Matrix3 i5(
- -0.01, 0.05, -0.00,
- 0.04, 0.01, 0.04,
- 0.04, 0.00, -0.04);
-
-
+ -0.01, 0.05, -0.00, 0.04, 0.01, 0.04, 0.04, 0.00, -0.04);
Matrix3 t1(
- -18.6f, 0.0f, -1.36e-08f,
- 1.88e-09f,13.2f, 13.2f,
- -6.85e-09f,13.2f, -13.2f);
+ -18.6f, 0.0f, -1.36e-08f, 1.88e-09f, 13.2f, 13.2f, -6.85e-09f, 13.2f, -13.2f);
Matrix3 t2(
- -18.6f,8.04e-09f, 3.01e-06f,
- 6.91e-06f,13.2f, 13.2f,
- 6.76e-06f,13.2f, -13.2f);
+ -18.6f, 8.04e-09f, 3.01e-06f, 6.91e-06f, 13.2f, 13.2f, 6.76e-06f, 13.2f, -13.2f);
Matrix3 t3(
- 6.24f,-17.6f, -0.0641f,
- -12.4f,-4.46f, 13.2f,
- -12.4f, -4.37f, -13.2f);
+ 6.24f, -17.6f, -0.0641f, -12.4f, -4.46f, 13.2f, -12.4f, -4.37f, -13.2f);
Matrix3 t4(
- -16.3f,9.05f, -0.0371f,
- 6.42f, 11.6f, 13.1f,
- 6.38f,11.4f, -13.3f);
+ -16.3f, 9.05f, -0.0371f, 6.42f, 11.6f, 13.1f, 6.38f, 11.4f, -13.3f);
Matrix3 t5(
- -2.43f,18.5f, -0.257f,
- 13.2f, 1.92f, 13.0f,
- 12.9f, 1.51f, -13.4f);
-
+ -2.43f, 18.5f, -0.257f, 13.2f, 1.92f, 13.0f, 12.9f, 1.51f, -13.4f);
-
-Matrix3* matrices[5] = { &m1, &m2, &m3, &m4, &m5 };
-Matrix3* inverseMatrices[5] = { &i1, &i2, &i3, &i4, &i5 };
-Matrix3* transposeMatrices[5] = { &t1, &t2, &t3, &t4, &t5 };
+Matrix3* matrices[5] = {&m1, &m2, &m3, &m4, &m5};
+Matrix3* inverseMatrices[5] = {&i1, &i2, &i3, &i4, &i5};
+Matrix3* transposeMatrices[5] = {&t1, &t2, &t3, &t4, &t5};
} // anonymous namespace
int UtcDaliMatrix3FromMatrix(void)
{
- float els0[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f};
- Matrix m0(els0);
- Matrix3 m1(0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f);
+ float els0[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
+ Matrix m0(els0);
+ Matrix3 m1(0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f);
Matrix3 m2(m0);
int UtcDaliMatrix3CopyConstructor(void)
{
- Matrix3 m0( Matrix3::IDENTITY );
- Matrix3 m1( m0 );
+ Matrix3 m0(Matrix3::IDENTITY);
+ Matrix3 m1(m0);
DALI_TEST_EQUALS(m1, Matrix3::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliMatrix3MoveConstructor(void)
{
- Matrix3 m0( Matrix3::IDENTITY );
- Matrix3 m1 = std::move( m0 );
+ Matrix3 m0(Matrix3::IDENTITY);
+ Matrix3 m1 = std::move(m0);
DALI_TEST_EQUALS(m1, Matrix3::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliMatrix3CopyAssignment(void)
{
- Matrix3 m0( Matrix3::IDENTITY );
+ Matrix3 m0(Matrix3::IDENTITY);
Matrix3 m1;
m1 = m0;
DALI_TEST_EQUALS(m1, Matrix3::IDENTITY, 0.001f, TEST_LOCATION);
int UtcDaliMatrix3MoveAssignment(void)
{
- Matrix3 m0( Matrix3::IDENTITY );
+ Matrix3 m0(Matrix3::IDENTITY);
Matrix3 m1;
- m1 = std::move( m0 );
+ m1 = std::move(m0);
DALI_TEST_EQUALS(m1, Matrix3::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliMatrix3OperatorAssign01(void)
{
- float els0[] = { 0.0f, 1.0f, 2.0f, 3.0f,
- 4.0f, 5.0f, 6.0f, 7.0f,
- 8.0f, 9.0f, 10.0f, 11.0f,
- 12.0f, 13.0f, 14.0f, 15.0f};
+ float els0[] = {0.0f, 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f};
Matrix m0(els0);
- Matrix3 m1(0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f);
+ Matrix3 m1(0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f);
Matrix3 m2;
m2 = m0;
END_TEST;
}
-
int UtcDaliMatrix3OperatorAssign02(void)
{
- Matrix3 m0(0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f);
+ Matrix3 m0(0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f);
- Matrix3 m1(0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f);
+ Matrix3 m1(0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f);
Matrix3 m2;
m2 = m0;
END_TEST;
}
-
-
// AsFloat
int UtcDaliMatrix3AsFloat(void)
{
- float values[] = {0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f };
+ float values[] = {0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f};
- Matrix3 m1(values[0], values[1], values[2], values[3],values[4], values[5], values[6], values[7],values[8]);
+ Matrix3 m1(values[0], values[1], values[2], values[3], values[4], values[5], values[6], values[7], values[8]);
- for (int i=0;i<9;++i)
+ for(int i = 0; i < 9; ++i)
{
- DALI_TEST_EQUALS(m1.AsFloat()[i], values[i], TEST_LOCATION);
+ DALI_TEST_EQUALS(m1.AsFloat()[i], values[i], TEST_LOCATION);
}
END_TEST;
}
-
// Invert works
int UtcDaliMatrix3Invert(void)
{
// We're going to invert a whole load of different matrices to make sure we don't
// fail on particular orientations.
- for (int i=0;i<5;++i)
+ for(int i = 0; i < 5; ++i)
{
- Matrix3 m = *matrices[i];
+ Matrix3 m = *matrices[i];
Matrix3 inverseResult1 = *inverseMatrices[i];
// Convert to Mat4, perform inverse, and convert back to Mat3
- float* mf = m.AsFloat();
- float els[] = { mf[0], mf[1], mf[2], 0.0f,
- mf[3], mf[4], mf[5], 0.0f,
- mf[6], mf[7], mf[8], 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f };
+ float* mf = m.AsFloat();
+ float els[] = {mf[0], mf[1], mf[2], 0.0f, mf[3], mf[4], mf[5], 0.0f, mf[6], mf[7], mf[8], 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
Matrix mat4(els);
mat4.Invert();
Matrix3 inverseResult2 = mat4;
DALI_TEST_EQUALS(mInv, inverseResult2, 0.01f, TEST_LOCATION);
Matrix3 m2 = mInv;
- m2.Invert(); // double invert - should be back to m
+ m2.Invert(); // double invert - should be back to m
DALI_TEST_EQUALS(m, m2, 0.01f, TEST_LOCATION);
}
int UtcDaliMatrix3Transpose(void)
{
- for (int i=0;i<5;++i)
+ for(int i = 0; i < 5; ++i)
{
Matrix3 m0 = *matrices[i];
Matrix3 trans = *transposeMatrices[i];
// SetIdentity
int UtcDaliMatrix3SetIdentity(void)
{
- Matrix3 m( 0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f);
+ Matrix3 m(0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f);
m.SetIdentity();
DALI_TEST_EQUALS(m, Matrix3::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliMatrix3Scale(void)
{
- Matrix3 m1( 0.0f, 1.0f, 2.0f,
- 4.0f, 5.0f, 6.0f,
- 8.0f, 9.0f, 10.0f);
+ Matrix3 m1(0.0f, 1.0f, 2.0f, 4.0f, 5.0f, 6.0f, 8.0f, 9.0f, 10.0f);
- Matrix3 m2( 0.0f, 3.0f, 6.0f,
- 12.0f, 15.0f, 18.0f,
- 24.0f, 27.0f, 30.0f);
+ Matrix3 m2(0.0f, 3.0f, 6.0f, 12.0f, 15.0f, 18.0f, 24.0f, 27.0f, 30.0f);
m1.Scale(3.0f);
int UtcDaliMatrix3Magnitude(void)
{
- Matrix3 m1( 0.0f, 1.0f, -2.0f,
- 3.0f, -4.0f, 5.0f,
- -6.0f, 7.0f, 8.0f);
+ Matrix3 m1(0.0f, 1.0f, -2.0f, 3.0f, -4.0f, 5.0f, -6.0f, 7.0f, 8.0f);
DALI_TEST_EQUALS(Matrix3::IDENTITY.Magnitude(), 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(m1.Magnitude(), 12.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliMatrix3ScaleInverseTranspose(void)
{
- Matrix3* matrices[6] = { &m1, &m2, &m3, &m4, &m5, &m6 };
+ Matrix3* matrices[6] = {&m1, &m2, &m3, &m4, &m5, &m6};
-
- for (int i=0;i<6;++i)
+ for(int i = 0; i < 6; ++i)
{
- Matrix3 m0 = *matrices[i];
+ Matrix3 m0 = *matrices[i];
Matrix3 m1 = m0;
m1.Invert();
m1.Transpose();
- m1.Scale(3.0f/(m1.Magnitude()));
+ m1.Scale(3.0f / (m1.Magnitude()));
Matrix3 m2 = m0;
m2.ScaledInverseTranspose();
{
std::ostringstream oss;
- Matrix3 matrix( 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f );
+ Matrix3 matrix(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f);
oss << matrix;
std::string expectedOutput = "[ 1, 2, 3, 4, 5, 6, 7, 8, 9 ]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
int UtcDaliMatrix3Multiply(void)
{
- Matrix3 m1( 0.0f, 3.0f, 6.0f,
- 12.0f, 15.0f, 18.0f,
- 24.0f, 27.0f, 30.0f);
+ Matrix3 m1(0.0f, 3.0f, 6.0f, 12.0f, 15.0f, 18.0f, 24.0f, 27.0f, 30.0f);
- Matrix3 m2( 0.0f, 1.0f, 0.0f,
- -1.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 1.0f);
+ Matrix3 m2(0.0f, 1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f);
- Matrix3 m3( -3.0f, 0.0f, 6.0f,
- -15.0f, 12.0f, 18.0f,
- -27.0f, 24.0f, 30.0f);
+ Matrix3 m3(-3.0f, 0.0f, 6.0f, -15.0f, 12.0f, 18.0f, -27.0f, 24.0f, 30.0f);
Matrix3 result;
Matrix3::Multiply(result, m1, m2);
int UtcDaliMatrix3EqualityOperator(void)
{
- Matrix3 m1( 0.0f, 3.0f, 6.0f,
- 12.0f, 15.0f, 18.0f,
- 24.0f, 27.0f, 30.0f);
+ Matrix3 m1(0.0f, 3.0f, 6.0f, 12.0f, 15.0f, 18.0f, 24.0f, 27.0f, 30.0f);
- Matrix3 m2( 0.0f, 3.0f, 6.0f,
- 12.0f, 15.0f, 18.0f,
- 24.0f, 27.0f, 30.0f);
+ Matrix3 m2(0.0f, 3.0f, 6.0f, 12.0f, 15.0f, 18.0f, 24.0f, 27.0f, 30.0f);
DALI_TEST_CHECK(m1 == m2);
END_TEST;
int UtcDaliMatrix3InequalityOperator(void)
{
- Matrix3 m1( 1.0f, 0.0f, 0.0f,
- 0.0f, 1.0f, 0.0f,
- 0.0f, 0.0f, 1.0f);
+ Matrix3 m1(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
- Matrix3 m2( 0.0f, 3.0f, 6.0f,
- 12.0f, 15.0f, 18.0f,
- 24.0f, 27.0f, 30.0f);
+ Matrix3 m2(0.0f, 3.0f, 6.0f, 12.0f, 15.0f, 18.0f, 24.0f, 27.0f, 30.0f);
DALI_TEST_CHECK(m1 != m2);
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <dali-test-suite-utils.h>
+#include <dali/devel-api/threading/mutex.h>
+#include <dali/devel-api/threading/thread.h>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
#include <unistd.h>
+
+#include <iostream>
#include <type_traits>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/threading/mutex.h>
-#include <dali/devel-api/threading/thread.h>
-#include <dali-test-suite-utils.h>
using Dali::Mutex;
using Dali::Thread;
{
Mutex mutex1;
- DALI_TEST_EQUALS( false, mutex1.IsLocked(), TEST_LOCATION );
+ DALI_TEST_EQUALS(false, mutex1.IsLocked(), TEST_LOCATION);
}
{
- Mutex mutex2;
- Mutex::ScopedLock lock( mutex2 );
- DALI_TEST_EQUALS( true, mutex2.IsLocked(), TEST_LOCATION );
+ Mutex mutex2;
+ Mutex::ScopedLock lock(mutex2);
+ DALI_TEST_EQUALS(true, mutex2.IsLocked(), TEST_LOCATION);
}
Mutex mutex3;
{
- Mutex::ScopedLock lock( mutex3 );
+ Mutex::ScopedLock lock(mutex3);
}
- DALI_TEST_EQUALS( false, mutex3.IsLocked(), TEST_LOCATION );
+ DALI_TEST_EQUALS(false, mutex3.IsLocked(), TEST_LOCATION);
END_TEST;
}
namespace // for local variables to avoid name clashes
{
// make all these volatile to pre-empt any optimization screwing up the logic
-volatile int gGlobalValue = 0;
-volatile bool gWorkerThreadWait = true;
-volatile enum ThreadState { INIT, RUN, LOCKING, TERMINATE } gWorkerThreadState = INIT;
+volatile int gGlobalValue = 0;
+volatile bool gWorkerThreadWait = true;
+volatile enum ThreadState { INIT,
+ RUN,
+ LOCKING,
+ TERMINATE } gWorkerThreadState = INIT;
Mutex* volatile gGlobalValueMutex; // volatile pointer to a mutex object
class TestThread : public Thread
{
gWorkerThreadState = RUN;
{
- Mutex::ScopedLock lock( *gGlobalValueMutex );
+ Mutex::ScopedLock lock(*gGlobalValueMutex);
gWorkerThreadState = LOCKING;
- gGlobalValue = -1;
- while( gWorkerThreadWait ) // wait till we can exit
+ gGlobalValue = -1;
+ while(gWorkerThreadWait) // wait till we can exit
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
}
gWorkerThreadState = TERMINATE;
}
};
-}
+} // namespace
int UtcDaliMutexMultiThread(void)
{
TestThread thread1;
// initialize values
- gGlobalValue = 0;
+ gGlobalValue = 0;
gWorkerThreadWait = true;
- DALI_TEST_EQUALS( INIT, gWorkerThreadState, TEST_LOCATION );
- DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
- DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+ DALI_TEST_EQUALS(INIT, gWorkerThreadState, TEST_LOCATION);
+ DALI_TEST_EQUALS(0, gGlobalValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, gGlobalValueMutex->IsLocked(), TEST_LOCATION);
// lock the mutex
{
- Mutex::ScopedLock lock( *gGlobalValueMutex );
- DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+ Mutex::ScopedLock lock(*gGlobalValueMutex);
+ DALI_TEST_EQUALS(true, gGlobalValueMutex->IsLocked(), TEST_LOCATION);
thread1.Start();
// wait till the thread is in run state
- while( RUN != gWorkerThreadState )
+ while(RUN != gWorkerThreadState)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
// now the thread is running and mutex is still locked by this thread so value is not changed
- DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0, gGlobalValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, gGlobalValueMutex->IsLocked(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0, gGlobalValue, TEST_LOCATION);
// drop out of scope, releases our lock
}
// now child thread is allowed to change the value
// wait till the thread is in locking state
- while( LOCKING != gWorkerThreadState )
+ while(LOCKING != gWorkerThreadState)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
// mutex is locked, but not by us, by the child thread
- DALI_TEST_EQUALS( true, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, gGlobalValueMutex->IsLocked(), TEST_LOCATION);
// value is changed
- DALI_TEST_EQUALS( -1, gGlobalValue, TEST_LOCATION );
+ DALI_TEST_EQUALS(-1, gGlobalValue, TEST_LOCATION);
// let worker finish
gWorkerThreadWait = false;
// wait till the thread is terminated state
- while( TERMINATE != gWorkerThreadState )
+ while(TERMINATE != gWorkerThreadState)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
- DALI_TEST_EQUALS( false, gGlobalValueMutex->IsLocked(), TEST_LOCATION );
+ DALI_TEST_EQUALS(false, gGlobalValueMutex->IsLocked(), TEST_LOCATION);
thread1.Join();
END_TEST;
{
// we want to make sure that mutex is not copyable (its copy constructor is not defined)
// this test will stop compiling if Mutex has compiler generated copy constructor
- static_assert( !__has_trivial_copy( Mutex ), "Mutex should NOT be copyable" );
+ static_assert(!__has_trivial_copy(Mutex), "Mutex should NOT be copyable");
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
-
-
*
*/
-#include <iostream>
-
-#include <stdlib.h>
#include <dali-test-suite-utils.h>
#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
// Functors to test whether Object created/destroyed signal is emitted for different types of Objects
struct TestObjectDestroyedCallback
}
}
- bool& mSignalVerified;
+ bool& mSignalVerified;
Dali::RefObject*& mObjectPointer;
};
TestApplication application;
ObjectRegistry registry; // like this for ctor code coverage
- registry= application.GetCore().GetObjectRegistry();
+ registry = application.GetCore().GetObjectRegistry();
- DALI_TEST_CHECK( registry );
+ DALI_TEST_CHECK(registry);
END_TEST;
}
TestApplication application;
ObjectRegistry myRegistry;
- ObjectRegistry anotherRegistry( myRegistry );
+ ObjectRegistry anotherRegistry(myRegistry);
- DALI_TEST_EQUALS( myRegistry, anotherRegistry, TEST_LOCATION );
+ DALI_TEST_EQUALS(myRegistry, anotherRegistry, TEST_LOCATION);
END_TEST;
}
TestApplication application;
ObjectRegistry registry = application.GetCore().GetObjectRegistry();
- DALI_TEST_CHECK( registry );
- DALI_TEST_EQUALS( 2, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(registry);
+ DALI_TEST_EQUALS(2, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- ObjectRegistry move = std::move( registry );
- DALI_TEST_CHECK( move );
+ ObjectRegistry move = std::move(registry);
+ DALI_TEST_CHECK(move);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !registry );
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!registry);
END_TEST;
}
TestApplication application;
ObjectRegistry registry = application.GetCore().GetObjectRegistry();
- DALI_TEST_CHECK( registry );
- DALI_TEST_EQUALS( 2, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(registry);
+ DALI_TEST_EQUALS(2, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
ObjectRegistry move;
- move = std::move( registry );
- DALI_TEST_CHECK( move );
+ move = std::move(registry);
+ DALI_TEST_CHECK(move);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !registry );
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!registry);
END_TEST;
}
{
tet_infoline("Testing GetObjectRegistry()");
TestApplication application;
- ObjectRegistry registry = application.GetCore().GetObjectRegistry();
- DALI_TEST_CHECK( registry );
+ ObjectRegistry registry = application.GetCore().GetObjectRegistry();
+ DALI_TEST_CHECK(registry);
- bool verified = false;
+ bool verified = false;
TestActorCallback test(verified);
- Dali::RefObject* objectPointer = NULL;
+ Dali::RefObject* objectPointer = NULL;
TestObjectDestroyedCallback test2(verified, objectPointer);
registry.ObjectCreatedSignal().Connect(&application, test);
{
Actor actor = Actor::New();
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
- verified = false;
+ verified = false;
objectPointer = actor.GetObjectPtr();
}
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
END_TEST;
}
ObjectRegistry registry = application.GetCore().GetObjectRegistry();
- bool verified = false;
+ bool verified = false;
TestCameraActorCallback test(verified);
- Dali::RefObject* objectPointer = NULL;
+ Dali::RefObject* objectPointer = NULL;
TestObjectDestroyedCallback test2(verified, objectPointer);
registry.ObjectCreatedSignal().Connect(&application, test);
{
CameraActor actor = CameraActor::New();
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
- verified = false;
+ verified = false;
objectPointer = actor.GetObjectPtr();
}
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
END_TEST;
}
int UtcDaliObjectRegistrySignalLayerCreated(void)
{
TestApplication application;
- ObjectRegistry registry = application.GetCore().GetObjectRegistry();
+ ObjectRegistry registry = application.GetCore().GetObjectRegistry();
- bool verified = false;
+ bool verified = false;
TestLayerCallback test(verified);
- Dali::RefObject* objectPointer = NULL;
+ Dali::RefObject* objectPointer = NULL;
TestObjectDestroyedCallback test2(verified, objectPointer);
registry.ObjectCreatedSignal().Connect(&application, test);
{
Layer actor = Layer::New();
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
- verified = false;
+ verified = false;
objectPointer = actor.GetObjectPtr();
}
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
END_TEST;
}
int UtcDaliObjectRegistrySignalAnimationCreated(void)
{
TestApplication application;
- ObjectRegistry registry = application.GetCore().GetObjectRegistry();
+ ObjectRegistry registry = application.GetCore().GetObjectRegistry();
- bool verified = false;
+ bool verified = false;
TestAnimationCallback test(verified);
- Dali::RefObject* objectPointer = NULL;
+ Dali::RefObject* objectPointer = NULL;
TestObjectDestroyedCallback test2(verified, objectPointer);
registry.ObjectCreatedSignal().Connect(&application, test);
{
Animation animation = Animation::New(1.0f);
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
- verified = false;
+ verified = false;
objectPointer = animation.GetObjectPtr();
}
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
END_TEST;
}
int UtcDaliObjectRegistryObjectCreatedSignalNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::ObjectRegistry instance;
try
{
int UtcDaliObjectRegistryObjectDestroyedSignalNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::ObjectRegistry instance;
try
{
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/events/pan-gesture-devel.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
{
TestApplication application; // Reset all test adapter return codes
- PanGesture gesture = DevelPanGesture::New( GestureState::CLEAR );
+ PanGesture gesture = DevelPanGesture::New(GestureState::CLEAR);
DALI_TEST_EQUALS(GestureState::CLEAR, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, gesture.GetType(), TEST_LOCATION);
- PanGesture gesture2 = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture2 = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(GestureState::STARTED, gesture2.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture2.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, gesture2.GetType(), TEST_LOCATION);
- PanGesture gesture3 = DevelPanGesture::New( GestureState::CONTINUING );
+ PanGesture gesture3 = DevelPanGesture::New(GestureState::CONTINUING);
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture3.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture3.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, gesture3.GetType(), TEST_LOCATION);
- PanGesture gesture4 = DevelPanGesture::New( GestureState::FINISHED );
+ PanGesture gesture4 = DevelPanGesture::New(GestureState::FINISHED);
DALI_TEST_EQUALS(GestureState::FINISHED, gesture4.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture4.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, gesture4.GetType(), TEST_LOCATION);
// Test copy constructor
- DevelPanGesture::SetNumberOfTouches( gesture4, 3u );
+ DevelPanGesture::SetNumberOfTouches(gesture4, 3u);
PanGesture pan(gesture4);
DALI_TEST_EQUALS(GestureState::FINISHED, pan.GetState(), TEST_LOCATION);
// Test move constructor
const auto refCount = gesture.GetObjectPtr()->ReferenceCount();
- PanGesture gesture5( std::move( gesture ) );
+ PanGesture gesture5(std::move(gesture));
DALI_TEST_CHECK(!gesture);
DALI_TEST_EQUALS(GestureType::PAN, gesture5.GetType(), TEST_LOCATION);
DALI_TEST_EQUALS(gesture5.GetBaseObject().ReferenceCount(), refCount, TEST_LOCATION);
int UtcDaliPanGestureAssignmentP(void)
{
// Test Assignment operator
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(GestureState::STARTED, gesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, gesture.GetType(), TEST_LOCATION);
- PanGesture gesture2 = DevelPanGesture::New( GestureState::CONTINUING );
+ PanGesture gesture2 = DevelPanGesture::New(GestureState::CONTINUING);
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture2.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, gesture2.GetNumberOfTouches(), TEST_LOCATION);
DALI_TEST_EQUALS(GestureType::PAN, gesture2.GetType(), TEST_LOCATION);
- DevelPanGesture::SetNumberOfTouches( gesture2, 3u );
+ DevelPanGesture::SetNumberOfTouches(gesture2, 3u);
gesture = gesture2;
DALI_TEST_EQUALS(GestureState::CONTINUING, gesture.GetState(), TEST_LOCATION);
int UtcDaliPanGestureGetSpeedP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(0.0f, gesture.GetSpeed(), TEST_LOCATION);
- DevelPanGesture::SetVelocity( gesture, Vector2( 3.0f, -4.0f ) );
+ DevelPanGesture::SetVelocity(gesture, Vector2(3.0f, -4.0f));
DALI_TEST_EQUALS(5.0f, gesture.GetSpeed(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureGetDistanceP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(0.0f, gesture.GetDistance(), TEST_LOCATION);
- DevelPanGesture::SetDisplacement( gesture, Vector2( -30.0f, -40.0f ) );
+ DevelPanGesture::SetDisplacement(gesture, Vector2(-30.0f, -40.0f));
DALI_TEST_EQUALS(50.0f, gesture.GetDistance(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureGetScreenSpeedP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(0.0f, gesture.GetScreenSpeed(), TEST_LOCATION);
- DevelPanGesture::SetScreenVelocity( gesture, Vector2( 3.0f, -4.0f ) );
+ DevelPanGesture::SetScreenVelocity(gesture, Vector2(3.0f, -4.0f));
DALI_TEST_EQUALS(5.0f, gesture.GetScreenSpeed(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureGetScreenDistanceP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(0.0f, gesture.GetScreenDistance(), TEST_LOCATION);
- DevelPanGesture::SetScreenDisplacement( gesture, Vector2( -30.0f, -40.0f ) );
+ DevelPanGesture::SetScreenDisplacement(gesture, Vector2(-30.0f, -40.0f));
DALI_TEST_EQUALS(50.0f, gesture.GetScreenDistance(), TEST_LOCATION);
END_TEST;
GestureDetector detector = PanGestureDetector::New();
- Property::Index index = detector.RegisterProperty( "sceneProperty", 0 );
- DALI_TEST_EQUALS( index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), 0, TEST_LOCATION );
- detector.SetProperty( index, -99 );
+ Property::Index index = detector.RegisterProperty("sceneProperty", 0);
+ DALI_TEST_EQUALS(index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), 0, TEST_LOCATION);
+ detector.SetProperty(index, -99);
using Dali::Animation;
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( detector, index ), 99 );
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), -99, TEST_LOCATION );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(detector, index), 99);
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), -99, TEST_LOCATION);
// create another pan gesture
GestureDetector detector2 = PanGestureDetector::New();
- DALI_TEST_EQUALS( detector2.GetProperty< int32_t >( index ), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector2.GetProperty<int32_t>(index), 0, TEST_LOCATION);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( 500 /* 50% progress */);
- DALI_TEST_EQUALS( detector.GetCurrentProperty< int32_t >( index ), 0 /*half way*/, TEST_LOCATION );
+ application.Render(500 /* 50% progress */);
+ DALI_TEST_EQUALS(detector.GetCurrentProperty<int32_t>(index), 0 /*half way*/, TEST_LOCATION);
// register another pan gesture value
- Property::Index index2 = detector2.RegisterProperty( "sceneProperty2", 12 );
- DALI_TEST_EQUALS( index2, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( detector2.GetProperty< int32_t >( index2 ), 12, TEST_LOCATION );
- DALI_TEST_EQUALS( detector2.GetCurrentProperty< int32_t >( index2 ), 12, TEST_LOCATION );
+ Property::Index index2 = detector2.RegisterProperty("sceneProperty2", 12);
+ DALI_TEST_EQUALS(index2, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector2.GetProperty<int32_t>(index2), 12, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector2.GetCurrentProperty<int32_t>(index2), 12, TEST_LOCATION);
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), 99 /*target*/, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetCurrentProperty< int32_t >( index ), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), 99 /*target*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetCurrentProperty<int32_t>(index), 0, TEST_LOCATION);
- Animation animation2 = Animation::New( 1.0f );
- animation2.AnimateTo( Property( detector2, index2 ), -99 );
+ Animation animation2 = Animation::New(1.0f);
+ animation2.AnimateTo(Property(detector2, index2), -99);
// Start the animation
animation2.Play();
application.SendNotification();
- application.Render( 1000 /* 100% more progress */);
+ application.Render(1000 /* 100% more progress */);
- DALI_TEST_EQUALS( detector2.GetProperty< int32_t >( index2 ), -99, TEST_LOCATION );
- DALI_TEST_EQUALS( detector2.GetCurrentProperty< int32_t >( index2 ), -99, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector2.GetProperty<int32_t>(index2), -99, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector2.GetCurrentProperty<int32_t>(index2), -99, TEST_LOCATION);
- DALI_TEST_EQUALS( detector.GetProperty< int32_t >( index ), 99, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetCurrentProperty< int32_t >( index ), 99, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetProperty<int32_t>(index), 99, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetCurrentProperty<int32_t>(index), 99, TEST_LOCATION);
END_TEST;
}
int UtcDaliPanGestureSetGetTimeP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(0, gesture.GetTime(), TEST_LOCATION);
- DevelPanGesture::SetTime( gesture, 123123 );
+ DevelPanGesture::SetTime(gesture, 123123);
DALI_TEST_EQUALS(123123, gesture.GetTime(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetVelocityP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(Vector2::ZERO, gesture.GetVelocity(), TEST_LOCATION);
- DevelPanGesture::SetVelocity( gesture, Vector2(123.0f, 321.0f) );
+ DevelPanGesture::SetVelocity(gesture, Vector2(123.0f, 321.0f));
DALI_TEST_EQUALS(Vector2(123.0f, 321.0f), gesture.GetVelocity(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetDisplacementP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(Vector2::ZERO, gesture.GetDisplacement(), TEST_LOCATION);
- DevelPanGesture::SetDisplacement( gesture, Vector2(123.0f, 321.0f) );
+ DevelPanGesture::SetDisplacement(gesture, Vector2(123.0f, 321.0f));
DALI_TEST_EQUALS(Vector2(123.0f, 321.0f), gesture.GetDisplacement(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetPositionP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(Vector2::ZERO, gesture.GetPosition(), TEST_LOCATION);
- DevelPanGesture::SetPosition( gesture, Vector2(123.0f, 321.0f) );
+ DevelPanGesture::SetPosition(gesture, Vector2(123.0f, 321.0f));
DALI_TEST_EQUALS(Vector2(123.0f, 321.0f), gesture.GetPosition(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetScreenVelocityP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(Vector2::ZERO, gesture.GetScreenVelocity(), TEST_LOCATION);
- DevelPanGesture::SetScreenVelocity( gesture, Vector2(123.0f, 321.0f) );
+ DevelPanGesture::SetScreenVelocity(gesture, Vector2(123.0f, 321.0f));
DALI_TEST_EQUALS(Vector2(123.0f, 321.0f), gesture.GetScreenVelocity(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetScreenDisplacementP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(Vector2::ZERO, gesture.GetScreenDisplacement(), TEST_LOCATION);
- DevelPanGesture::SetScreenDisplacement( gesture, Vector2(123.0f, 321.0f) );
+ DevelPanGesture::SetScreenDisplacement(gesture, Vector2(123.0f, 321.0f));
DALI_TEST_EQUALS(Vector2(123.0f, 321.0f), gesture.GetScreenDisplacement(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetScreenPositionP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(Vector2::ZERO, gesture.GetScreenPosition(), TEST_LOCATION);
- DevelPanGesture::SetScreenPosition( gesture, Vector2(123.0f, 321.0f) );
+ DevelPanGesture::SetScreenPosition(gesture, Vector2(123.0f, 321.0f));
DALI_TEST_EQUALS(Vector2(123.0f, 321.0f), gesture.GetScreenPosition(), TEST_LOCATION);
END_TEST;
int UtcDaliPanGestureSetGetNumberOfTouchesP(void)
{
- PanGesture gesture = DevelPanGesture::New( GestureState::STARTED );
+ PanGesture gesture = DevelPanGesture::New(GestureState::STARTED);
DALI_TEST_EQUALS(1u, gesture.GetNumberOfTouches(), TEST_LOCATION);
- DevelPanGesture::SetNumberOfTouches( gesture, 3123 );
+ DevelPanGesture::SetNumberOfTouches(gesture, 3123);
DALI_TEST_EQUALS(3123, gesture.GetNumberOfTouches(), TEST_LOCATION);
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <cmath>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/pan-gesture-devel.h>
#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/render-task-list-integ.h>
-#include <dali/integration-api/profiling.h>
#include <dali/integration-api/input-options.h>
-#include <dali-test-suite-utils.h>
+#include <dali/integration-api/profiling.h>
+#include <dali/integration-api/render-task-list-integ.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
#include <test-touch-event-utils.h>
-#include <dali/devel-api/events/pan-gesture-devel.h>
+
+#include <cmath>
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-const int PAN_EVENT_TIME_DELTA = 8;
+const int PAN_EVENT_TIME_DELTA = 8;
const int PAN_GESTURE_UPDATE_COUNT = 50;
// Stores data that is populated in the callback and will be read by the test cases
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pannedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
PanGesture receivedGesture;
- Actor pannedActor;
+ Actor pannedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const PanGesture& pan)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = pan;
- signalData.pannedActor = actor;
+ signalData.pannedActor = actor;
}
void operator()()
// Functor that removes the gestured actor from stage
struct UnstageActorFunctor : public GestureReceivedFunctor
{
- UnstageActorFunctor( SignalData& data, GestureState& stateToUnstage, Integration::Scene scene )
- : GestureReceivedFunctor( data ),
- stateToUnstage( stateToUnstage ),
- scene( scene )
+ UnstageActorFunctor(SignalData& data, GestureState& stateToUnstage, Integration::Scene scene)
+ : GestureReceivedFunctor(data),
+ stateToUnstage(stateToUnstage),
+ scene(scene)
{
}
- void operator()( Actor actor, const PanGesture& pan )
+ void operator()(Actor actor, const PanGesture& pan)
{
- GestureReceivedFunctor::operator()( actor, pan );
+ GestureReceivedFunctor::operator()(actor, pan);
- if ( pan.GetState() == stateToUnstage )
+ if(pan.GetState() == stateToUnstage)
{
- scene.Remove( actor );
+ scene.Remove(actor);
}
}
- GestureState& stateToUnstage;
+ GestureState& stateToUnstage;
Integration::Scene scene;
};
struct ConstraintData
{
ConstraintData()
- : panning( false ),
- called( false )
+ : panning(false),
+ called(false)
{
}
Vector2 localPosition;
Vector2 localDisplacement;
Vector2 localVelocity;
- bool panning;
- bool called;
+ bool panning;
+ bool called;
void Reset()
{
screenPosition = screenDisplacement = screenVelocity = localPosition = localDisplacement = localVelocity = Vector2::ZERO;
- panning = false;
- called = false;
+ panning = false;
+ called = false;
}
};
// Constraint used with panning properties
struct PanConstraint
{
- PanConstraint( ConstraintData& data ) : constraintData(data) { }
+ PanConstraint(ConstraintData& data)
+ : constraintData(data)
+ {
+ }
- void operator()( Vector3& current, const PropertyInputContainer& inputs )
+ void operator()(Vector3& current, const PropertyInputContainer& inputs)
{
- constraintData.screenPosition = inputs[0]->GetVector2();
+ constraintData.screenPosition = inputs[0]->GetVector2();
constraintData.screenDisplacement = inputs[1]->GetVector2();
- constraintData.screenVelocity = inputs[2]->GetVector2();
- constraintData.localPosition = inputs[3]->GetVector2();
- constraintData.localDisplacement = inputs[4]->GetVector2();
- constraintData.localVelocity = inputs[5]->GetVector2();
- constraintData.panning = inputs[6]->GetBoolean();
- constraintData.called = true;
- current = Vector3::ZERO;
+ constraintData.screenVelocity = inputs[2]->GetVector2();
+ constraintData.localPosition = inputs[3]->GetVector2();
+ constraintData.localDisplacement = inputs[4]->GetVector2();
+ constraintData.localVelocity = inputs[5]->GetVector2();
+ constraintData.panning = inputs[6]->GetBoolean();
+ constraintData.called = true;
+ current = Vector3::ZERO;
}
ConstraintData& constraintData;
};
// Generate a PanGesture
-PanGesture GeneratePan( unsigned int time,
- GestureState state,
- Vector2 screenPosition,
- Vector2 localPosition,
- Vector2 screenDisplacement = Vector2::ONE,
- Vector2 localDisplacement = Vector2::ONE,
- Vector2 screenVelocity = Vector2::ONE,
- Vector2 localVelocity = Vector2::ONE,
- unsigned int numberOfTouches = 1 )
+PanGesture GeneratePan(unsigned int time,
+ GestureState state,
+ Vector2 screenPosition,
+ Vector2 localPosition,
+ Vector2 screenDisplacement = Vector2::ONE,
+ Vector2 localDisplacement = Vector2::ONE,
+ Vector2 screenVelocity = Vector2::ONE,
+ Vector2 localVelocity = Vector2::ONE,
+ unsigned int numberOfTouches = 1)
{
- Dali::PanGesture pan = DevelPanGesture::New( state );
+ Dali::PanGesture pan = DevelPanGesture::New(state);
- DevelPanGesture::SetTime( pan, time );
+ DevelPanGesture::SetTime(pan, time);
- DevelPanGesture::SetScreenPosition( pan, screenPosition );
- DevelPanGesture::SetPosition( pan, localPosition );
+ DevelPanGesture::SetScreenPosition(pan, screenPosition);
+ DevelPanGesture::SetPosition(pan, localPosition);
- DevelPanGesture::SetScreenDisplacement( pan, screenDisplacement );
- DevelPanGesture::SetDisplacement( pan, localDisplacement );
+ DevelPanGesture::SetScreenDisplacement(pan, screenDisplacement);
+ DevelPanGesture::SetDisplacement(pan, localDisplacement);
- DevelPanGesture::SetScreenVelocity( pan, screenVelocity );
- DevelPanGesture::SetVelocity( pan, localVelocity );
+ DevelPanGesture::SetScreenVelocity(pan, screenVelocity);
+ DevelPanGesture::SetVelocity(pan, localVelocity);
- DevelPanGesture::SetNumberOfTouches( pan, numberOfTouches );
+ DevelPanGesture::SetNumberOfTouches(pan, numberOfTouches);
return pan;
}
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
PanGestureDetector detector = PanGestureDetector::New();
- PanGestureDetector copy( detector );
- DALI_TEST_CHECK( detector );
+ PanGestureDetector copy(detector);
+ DALI_TEST_CHECK(detector);
END_TEST;
}
PanGestureDetector assign;
assign = detector;
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(detector);
- DALI_TEST_CHECK( detector == assign );
+ DALI_TEST_CHECK(detector == assign);
END_TEST;
}
// Attach an actor and emit a touch event on the actor to ensure complete line coverage
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
detector.Attach(actor);
application.GetScene().Add(actor);
application.Render();
// Use long press function for touch event
- TestStartLongPress( application );
+ TestStartLongPress(application);
END_TEST;
}
PanGestureDetector detector2 = PanGestureDetector::DownCast(object);
DALI_TEST_CHECK(detector2);
- PanGestureDetector detector3 = DownCast< PanGestureDetector >(object);
+ PanGestureDetector detector3 = DownCast<PanGestureDetector>(object);
DALI_TEST_CHECK(detector3);
- BaseHandle unInitializedObject;
+ BaseHandle unInitializedObject;
PanGestureDetector detector4 = PanGestureDetector::DownCast(unInitializedObject);
DALI_TEST_CHECK(!detector4);
- PanGestureDetector detector5 = DownCast< PanGestureDetector >(unInitializedObject);
+ PanGestureDetector detector5 = DownCast<PanGestureDetector>(unInitializedObject);
DALI_TEST_CHECK(!detector5);
- GestureDetector detector6 = PanGestureDetector::New();
+ GestureDetector detector6 = PanGestureDetector::New();
PanGestureDetector detector7 = PanGestureDetector::DownCast(detector6);
DALI_TEST_CHECK(detector7);
END_TEST;
// Attach an actor and change the minimum touches
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.Attach(actor);
// Attach an actor and change the maximum touches
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.Attach(actor);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Do a pan outside actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2(110.0f, 110.0f), Vector2(121.0f, 121.0f), time );
+ TestStartPan(application, Vector2(110.0f, 110.0f), Vector2(121.0f, 121.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Continue pan into actor's area - we should still not receive the signal
data.Reset();
- TestMovePan( application, Vector2(20.0f, 20.0f), time );
+ TestMovePan(application, Vector2(20.0f, 20.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Stop panning - we should still not receive the signal
data.Reset();
- TestEndPan( application, Vector2(12.0f, 12.0f), time);
+ TestEndPan(application, Vector2(12.0f, 12.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start pan within the actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the pan within the actor's area - we should still receive the signal
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Pan Gesture leaves actor's area - we should still receive the signal
data.Reset();
- TestMovePan( application, Vector2(346.0f, 4.0f), time );
+ TestMovePan(application, Vector2(346.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Gesture ends - we would receive a finished state
data.Reset();
- TestEndPan( application, Vector2(314.0f, 4.0f), time );
+ TestEndPan(application, Vector2(314.0f, 4.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start pan within the actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the pan within the actor's area - we should still receive the signal
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Gesture ends within actor's area - we would receive a finished state
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start pan within the actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Continue the pan within the actor's area - we should still receive the signal
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Ensure we are no longer signalled
data.Reset();
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start pan within the actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
application.SendNotification();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Continue the pan within the actor's area - we should still receive the signal
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
{
TestApplication application;
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Attach a temporary actor to stop detector being removed from PanGestureProcessor when main actor
// is destroyed.
Actor tempActor = Actor::New();
- tempActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- tempActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
+ tempActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ tempActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.GetScene().Add(tempActor);
detector.Attach(tempActor);
// Actor lifetime is scoped
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
// Start pan within the actor's area
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Continue the pan within the actor's area - we should still receive the signal
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Gesture ends within the area where the actor used to be
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Do an entire pan, only check finished value
uint32_t time = 100;
- TestStartPan( application, Vector2( 11.0f, 12.0f ), Vector2( 27.0f, 12.0f ), time );
+ TestStartPan(application, Vector2(11.0f, 12.0f), Vector2(27.0f, 12.0f), time);
data.Reset();
- TestEndPan( application, Vector2(25.0f, 28.0f), time );
+ TestEndPan(application, Vector2(25.0f, 28.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(16.0f, 2.0f), data.receivedGesture.GetDisplacement(), 0.01f, TEST_LOCATION); // Actor relative
// Rotate actor again and render a couple of times
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do an entire pan, only check finished value
- TestStartPan( application, Vector2( 11.0f, 12.0f ), Vector2( 27.0f, 12.0f ), time );
+ TestStartPan(application, Vector2(11.0f, 12.0f), Vector2(27.0f, 12.0f), time);
data.Reset();
- TestEndPan( application, Vector2(25.0f, 28.0f), time );
+ TestEndPan(application, Vector2(25.0f, 28.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(2.0f, -16.0f), data.receivedGesture.GetDisplacement(), 0.01f, TEST_LOCATION); // Actor relative
// Rotate actor again and render a couple of times
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(270.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(270.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do an entire pan, only check finished value
- TestStartPan( application, Vector2( 11.0f, 12.0f ), Vector2( 27.0f, 12.0f ), time );
+ TestStartPan(application, Vector2(11.0f, 12.0f), Vector2(27.0f, 12.0f), time);
data.Reset();
- TestEndPan( application, Vector2(25.0f, 28.0f), time );
+ TestEndPan(application, Vector2(25.0f, 28.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(-16.0f, -2.0f), data.receivedGesture.GetDisplacement(), 0.01f, TEST_LOCATION); // Actor relative
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
// Set child to completely cover parent.
// Change rotation of child to be different from parent so that we can check if our local coordinate
// conversion of the parent actor is correct.
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- child.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
parent.Add(child);
-
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Do an entire pan, only check finished value - hits child area but parent should still receive it
uint32_t time = 100;
- TestStartPan( application, Vector2( 11.0f, 12.0f ), Vector2( 27.0f, 12.0f ), time );
+ TestStartPan(application, Vector2(11.0f, 12.0f), Vector2(27.0f, 12.0f), time);
data.Reset();
- TestEndPan( application, Vector2(25.0f, 28.0f), time );
+ TestEndPan(application, Vector2(25.0f, 28.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, parent == data.pannedActor, TEST_LOCATION);
detector.Detach(parent);
// Do an entire pan, only check finished value
- TestStartPan( application, Vector2( 11.0f, 12.0f ), Vector2( 27.0f, 12.0f ), time );
+ TestStartPan(application, Vector2(11.0f, 12.0f), Vector2(27.0f, 12.0f), time);
data.Reset();
- TestEndPan( application, Vector2(25.0f, 28.0f), time );
+ TestEndPan(application, Vector2(25.0f, 28.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, child == data.pannedActor, TEST_LOCATION);
TestApplication application;
Actor first = Actor::New();
- first.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- first.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(first);
Actor second = Actor::New();
- second.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- second.SetProperty( Actor::Property::POSITION_X, 100.0f);
- second.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ second.SetProperty(Actor::Property::POSITION_X, 100.0f);
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(second);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start pan within second actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2( 110.0f, 20.0f ), Vector2( 126.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(110.0f, 20.0f), Vector2(126.0f, 20.0f), time);
DALI_TEST_EQUALS(application.GetScene().GetRootLayer(), first.GetParent(), TEST_LOCATION);
DALI_TEST_EQUALS(application.GetScene().GetRootLayer(), second.GetParent(), TEST_LOCATION);
// Pan moves into first actor's area - second actor should receive the pan
data.Reset();
- TestMovePan( application, Vector2(126.0f, 20.0f), time );
+ TestMovePan(application, Vector2(126.0f, 20.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestMovePan( application, Vector2(26.0f, 20.0f), time );
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start pan in actor's area
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Pan continues within actor's area
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Actor become invisible - actor should not receive the next pan
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// Render and notify
application.SendNotification();
// Gesture ends within actor's area
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.GetScene().Add(actor2);
// Render and notify
application.Render();
// Attach actor to one detector
- SignalData firstData;
+ SignalData firstData;
GestureReceivedFunctor firstFunctor(firstData);
- PanGestureDetector firstDetector = PanGestureDetector::New();
+ PanGestureDetector firstDetector = PanGestureDetector::New();
firstDetector.Attach(actor);
firstDetector.DetectedSignal().Connect(&application, firstFunctor);
// Attach actor to another detector
- SignalData secondData;
+ SignalData secondData;
GestureReceivedFunctor secondFunctor(secondData);
- PanGestureDetector secondDetector = PanGestureDetector::New();
+ PanGestureDetector secondDetector = PanGestureDetector::New();
secondDetector.Attach(actor);
secondDetector.DetectedSignal().Connect(&application, secondFunctor);
// Pan in actor's area - both detector's functors should be called
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
firstData.Reset();
secondData.Reset();
- TestMovePan( application, Vector2(10.0f, 20.0f), time );
+ TestMovePan(application, Vector2(10.0f, 20.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
firstData.Reset();
secondData.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
firstData.Reset();
secondData.Reset();
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
firstData.Reset();
secondData.Reset();
- TestMovePan( application, Vector2(10.0f, 20.0f), time );
+ TestMovePan(application, Vector2(10.0f, 20.0f), time);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(false, secondData.functorCalled, TEST_LOCATION);
TestApplication application;
Actor actor1 = Actor::New();
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor1);
- SignalData data1;
+ SignalData data1;
GestureReceivedFunctor functor1(data1);
- PanGestureDetector detector1 = PanGestureDetector::New();
+ PanGestureDetector detector1 = PanGestureDetector::New();
detector1.Attach(actor1);
detector1.DetectedSignal().Connect(&application, functor1);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
- actor2.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_RIGHT);
application.GetScene().Add(actor2);
- SignalData data2;
+ SignalData data2;
GestureReceivedFunctor functor2(data2);
- PanGestureDetector detector2 = PanGestureDetector::New();
+ PanGestureDetector detector2 = PanGestureDetector::New();
detector2.Attach(actor2);
detector2.DetectedSignal().Connect(&application, functor2);
// Start pan in actor1's area, only data1 should be set
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data1.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
// Gesture possible in actor's area (using long-press)
uint32_t time = 100;
- TestStartLongPress( application, 10.0f, 20.0f, time );
+ TestStartLongPress(application, 10.0f, 20.0f, time);
time += TestGetFrameInterval();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
- PanGestureDetector detector = PanGestureDetector::New();
- detector.DetectedSignal().Connect( &application, functor );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ PanGestureDetector detector = PanGestureDetector::New();
+ detector.DetectedSignal().Connect(&application, functor);
detector.Attach(actor);
// Start a pan, initially it'll only be possible, we shouldn't receive it
- TestMovePan( application, Vector2( 10.0f, 20.0f ), time );
+ TestMovePan(application, Vector2(10.0f, 20.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Now the pan truly starts, we should receive a signal
- TestMovePan( application, Vector2( 26.0f, 20.0f ), time );
+ TestMovePan(application, Vector2(26.0f, 20.0f), time);
time += TestGetFrameInterval();
- TestMovePan( application, Vector2( 32.0f, 32.0f ), time );
+ TestMovePan(application, Vector2(32.0f, 32.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Finish the pan, we should still receive a signal
data.Reset();
- TestEndPan( application, Vector2( 32.0f, 32.0f ), time );
+ TestEndPan(application, Vector2(32.0f, 32.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( parent );
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- parent.Add( child );
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ parent.Add(child);
// Create detector for parent and attach
- SignalData parentData;
- GestureReceivedFunctor parentFunctor( parentData );
- PanGestureDetector parentDetector = PanGestureDetector::New();
- parentDetector.DetectedSignal().Connect( &application, parentFunctor );
- parentDetector.Attach( parent );
+ SignalData parentData;
+ GestureReceivedFunctor parentFunctor(parentData);
+ PanGestureDetector parentDetector = PanGestureDetector::New();
+ parentDetector.DetectedSignal().Connect(&application, parentFunctor);
+ parentDetector.Attach(parent);
// Create detector for child but do not attach
- SignalData childData;
- GestureReceivedFunctor childFunctor( childData );
- PanGestureDetector childDetector = PanGestureDetector::New();
- childDetector.DetectedSignal().Connect( &application, childFunctor );
+ SignalData childData;
+ GestureReceivedFunctor childFunctor(childData);
+ PanGestureDetector childDetector = PanGestureDetector::New();
+ childDetector.DetectedSignal().Connect(&application, childFunctor);
// Render and notify
application.SendNotification();
// Do a full pan in both actors' area, only the parent's functor should be called
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- DALI_TEST_EQUALS( parentData.functorCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( childData.functorCalled, false, TEST_LOCATION );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ DALI_TEST_EQUALS(parentData.functorCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(childData.functorCalled, false, TEST_LOCATION);
parentData.Reset();
childData.Reset();
- TestEndPan( application, Vector2( 26.0f, 20.0f ), time );
- DALI_TEST_EQUALS( parentData.functorCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( childData.functorCalled, false, TEST_LOCATION );
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
+ DALI_TEST_EQUALS(parentData.functorCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(childData.functorCalled, false, TEST_LOCATION);
parentData.Reset();
childData.Reset();
// Gesture possible in both actors' area (using long-press), no functors called
- TestStartLongPress( application, 10.0f, 20.0f, time );
+ TestStartLongPress(application, 10.0f, 20.0f, time);
time += TestGetFrameInterval();
- DALI_TEST_EQUALS( parentData.functorCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( childData.functorCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(parentData.functorCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(childData.functorCalled, false, TEST_LOCATION);
// Attach the child as well now
- childDetector.Attach( child );
+ childDetector.Attach(child);
// Now the pan truly starts, we should receive a signal for the child only
- TestMovePan( application, Vector2( 26.0f, 20.0f ), time );
+ TestMovePan(application, Vector2(26.0f, 20.0f), time);
time += TestGetFrameInterval();
- TestMovePan( application, Vector2( 32.0f, 32.0f ), time );
+ TestMovePan(application, Vector2(32.0f, 32.0f), time);
time += TestGetFrameInterval();
- DALI_TEST_EQUALS( parentData.functorCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( childData.functorCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(parentData.functorCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(childData.functorCalled, true, TEST_LOCATION);
parentData.Reset();
childData.Reset();
// Finish the pan, again only the child should still receive a signal
- TestEndPan( application, Vector2( 32.0f, 32.0f ), time );
- DALI_TEST_EQUALS( parentData.functorCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( childData.functorCalled, true, TEST_LOCATION );
+ TestEndPan(application, Vector2(32.0f, 32.0f), time);
+ DALI_TEST_EQUALS(parentData.functorCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(childData.functorCalled, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
- PanGestureDetector detector = PanGestureDetector::New();
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ PanGestureDetector detector = PanGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Gesture possible in actor's area.
uint32_t time = 100;
- TestStartLongPress( application, 10.0f, 20.0f, time );
+ TestStartLongPress(application, 10.0f, 20.0f, time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Move actor somewhere else
- actor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
// Render and notify
application.SendNotification();
application.Render();
// Emit STARTED event, we should not receive the pan.
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestEndPan( application, Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// LONG_PRESS possible in empty area.
- TestStartLongPress( application, 10.0f, 20.0f, time );
+ TestStartLongPress(application, 10.0f, 20.0f, time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Move actor in to the long press position.
- actor.SetProperty( Actor::Property::POSITION, Vector2( 0.0f, 0.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
// Render and notify
application.SendNotification();
application.Render();
// Emit STARTED event, we should be receiving the pan now.
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestEndPan( application, Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Normal pan in actor's area for completeness.
data.Reset();
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestEndPan( application, Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
- PanGestureDetector detector = PanGestureDetector::New();
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
+ PanGestureDetector detector = PanGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit signals
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPan( application, Vector2(26.0f, 20.0f), time );
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
stateToUnstage = GestureState::CONTINUING;
// Emit signals
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
stateToUnstage = GestureState::FINISHED;
// Emit signals
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- tet_result( TET_PASS ); // If we get here then we have handled actor stage removal gracefully.
+ tet_result(TET_PASS); // If we get here then we have handled actor stage removal gracefully.
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Create and add a second actor so that GestureDetector destruction does not come into play.
- Actor dummyActor( Actor::New() );
- dummyActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- dummyActor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- dummyActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ Actor dummyActor(Actor::New());
+ dummyActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(dummyActor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
- PanGestureDetector detector = PanGestureDetector::New();
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
+ PanGestureDetector detector = PanGestureDetector::New();
detector.Attach(actor);
detector.Attach(dummyActor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Here we are testing a STARTED actor which is removed in the STARTED callback, but then added back
// before we get a continuing state. As we were removed from the stage, even if we're at the same
// Emit signals
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Here we delete an actor in started, we should not receive any subsequent signalling.
// Emit signals
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPan( application, Vector2(10.0f, 4.0f), time );
+ TestEndPan(application, Vector2(10.0f, 4.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
- DALI_TEST_EQUALS( detector.GetAngleCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 0u, TEST_LOCATION);
- detector.AddAngle( PanGestureDetector::DIRECTION_LEFT, Radian( Math::PI * 0.25 ) );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 1u, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_LEFT, Radian(Math::PI * 0.25));
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 1u, TEST_LOCATION);
bool found = false;
- for( size_t i = 0; i < detector.GetAngleCount(); i++)
+ for(size_t i = 0; i < detector.GetAngleCount(); i++)
{
- if( detector.GetAngle(i).first == PanGestureDetector::DIRECTION_LEFT )
+ if(detector.GetAngle(i).first == PanGestureDetector::DIRECTION_LEFT)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
found = true;
break;
}
}
- if(!found )
+ if(!found)
{
- tet_printf("%s, angle not added\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ tet_printf("%s, angle not added\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- detector.AddAngle( PanGestureDetector::DIRECTION_RIGHT, Radian( Math::PI * 0.25 ) );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 2u, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_RIGHT, Radian(Math::PI * 0.25));
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 2u, TEST_LOCATION);
// Remove something not in the container.
- detector.RemoveAngle( PanGestureDetector::DIRECTION_UP );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 2u, TEST_LOCATION );
+ detector.RemoveAngle(PanGestureDetector::DIRECTION_UP);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 2u, TEST_LOCATION);
- detector.RemoveAngle( PanGestureDetector::DIRECTION_RIGHT );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 1u, TEST_LOCATION );
- for ( size_t i = 0; i < detector.GetAngleCount(); i++)
+ detector.RemoveAngle(PanGestureDetector::DIRECTION_RIGHT);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 1u, TEST_LOCATION);
+ for(size_t i = 0; i < detector.GetAngleCount(); i++)
{
- if ( detector.GetAngle(i).first == PanGestureDetector::DIRECTION_RIGHT )
+ if(detector.GetAngle(i).first == PanGestureDetector::DIRECTION_RIGHT)
{
- tet_printf("%s, angle not removed\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ tet_printf("%s, angle not removed\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
break;
}
}
detector.ClearAngles();
- DALI_TEST_EQUALS( detector.GetAngleCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 0u, TEST_LOCATION);
END_TEST;
}
TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
- DALI_TEST_EQUALS( detector.GetAngleCount(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 0, TEST_LOCATION);
- detector.AddAngle( PanGestureDetector::DIRECTION_LEFT );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 1, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_LEFT);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 1, TEST_LOCATION);
- detector.AddAngle( PanGestureDetector::DIRECTION_RIGHT );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 2, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_RIGHT);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 2, TEST_LOCATION);
- detector.AddAngle( PanGestureDetector::DIRECTION_UP );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 3, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_UP);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 3, TEST_LOCATION);
- detector.AddAngle( PanGestureDetector::DIRECTION_DOWN );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 4, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_DOWN);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 4, TEST_LOCATION);
- DALI_TEST_EQUALS( detector.GetAngle(0).first, PanGestureDetector::DIRECTION_LEFT, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetAngle(1).first, PanGestureDetector::DIRECTION_RIGHT, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetAngle(2).first, PanGestureDetector::DIRECTION_UP, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetAngle(3).first, PanGestureDetector::DIRECTION_DOWN, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, PanGestureDetector::DIRECTION_LEFT, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetAngle(1).first, PanGestureDetector::DIRECTION_RIGHT, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetAngle(2).first, PanGestureDetector::DIRECTION_UP, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetAngle(3).first, PanGestureDetector::DIRECTION_DOWN, TEST_LOCATION);
END_TEST;
}
-inline float RadiansToDegrees( float radian )
+inline float RadiansToDegrees(float radian)
{
return radian * 180.0f / Math::PI;
}
TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
- DALI_TEST_EQUALS( detector.GetAngleCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 0u, TEST_LOCATION);
//
// Angle
//
- detector.AddAngle( Degree(180.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(-180.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(180.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(-180.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( Degree(190.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(-170.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(190.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(-170.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( Degree(-190.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(170.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(-190.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(170.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( Degree(350.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(-10.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(350.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(-10.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( Degree(-350.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(10.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(-350.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(10.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( Degree(370.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(10.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(370.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(10.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( Degree(-370.0f) );
- DALI_TEST_EQUALS( detector.GetAngle(0).first, Radian( Degree(-10.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(Degree(-370.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).first, Radian(Degree(-10.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
//
// Threshold
//
- detector.AddAngle( PanGestureDetector::DIRECTION_RIGHT, Degree( 0.0f ) );
- DALI_TEST_EQUALS( detector.GetAngle(0).second, Radian( Degree(0.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_RIGHT, Degree(0.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).second, Radian(Degree(0.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( PanGestureDetector::DIRECTION_RIGHT, Degree( -10.0f ) );
- DALI_TEST_EQUALS( detector.GetAngle(0).second, Radian( Degree(10.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_RIGHT, Degree(-10.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).second, Radian(Degree(10.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( PanGestureDetector::DIRECTION_RIGHT, Degree( -181.0f ) );
- DALI_TEST_EQUALS( detector.GetAngle(0).second, Radian( Degree(180.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_RIGHT, Degree(-181.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).second, Radian(Degree(180.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
- detector.AddAngle( PanGestureDetector::DIRECTION_RIGHT, Degree( 181.0f ) );
- DALI_TEST_EQUALS( detector.GetAngle(0).second, Radian( Degree(180.0f) ), 0.000001, TEST_LOCATION );
+ detector.AddAngle(PanGestureDetector::DIRECTION_RIGHT, Degree(181.0f));
+ DALI_TEST_EQUALS(detector.GetAngle(0).second, Radian(Degree(180.0f)), 0.000001, TEST_LOCATION);
detector.ClearAngles();
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(child);
// Render and notify
// Parent detector only requires up pans
PanGestureDetector parentDetector = PanGestureDetector::New();
- parentDetector.Attach( parent );
- parentDetector.AddAngle( PanGestureDetector::DIRECTION_UP, Degree( 30.0f ) );
- SignalData parentData;
+ parentDetector.Attach(parent);
+ parentDetector.AddAngle(PanGestureDetector::DIRECTION_UP, Degree(30.0f));
+ SignalData parentData;
GestureReceivedFunctor parentFunctor(parentData);
parentDetector.DetectedSignal().Connect(&application, parentFunctor);
// Child detector only requires right pans
PanGestureDetector childDetector = PanGestureDetector::New();
- childDetector.Attach( child );
- childDetector.AddAngle( PanGestureDetector::DIRECTION_RIGHT, Degree( 30.0f ) );
- SignalData childData;
+ childDetector.Attach(child);
+ childDetector.AddAngle(PanGestureDetector::DIRECTION_RIGHT, Degree(30.0f));
+ SignalData childData;
GestureReceivedFunctor childFunctor(childData);
childDetector.DetectedSignal().Connect(&application, childFunctor);
// Generate an Up pan gesture, only parent should receive it.
uint32_t time = 100;
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 20.0f, 4.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(20.0f, 4.0f), time);
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 4.0f), time );
+ TestEndPan(application, Vector2(20.0f, 4.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a Right pan gesture, only child should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 36.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(36.0f, 20.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(4.0f, 20.0f), time );
+ TestEndPan(application, Vector2(4.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a Down pan gesture, no one should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 20.0f, 36.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(20.0f, 36.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 36.0f), time );
+ TestEndPan(application, Vector2(20.0f, 36.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a Left pan gesture, no one should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 4.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(4.0f, 20.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(4.0f, 20.0f), time );
+ TestEndPan(application, Vector2(4.0f, 20.0f), time);
parentData.Reset();
childData.Reset();
END_TEST;
TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
- DALI_TEST_EQUALS( detector.GetAngleCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 0u, TEST_LOCATION);
- detector.AddDirection( PanGestureDetector::DIRECTION_LEFT, Radian( Math::PI * 0.25 ) );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 2u, TEST_LOCATION );
+ detector.AddDirection(PanGestureDetector::DIRECTION_LEFT, Radian(Math::PI * 0.25));
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 2u, TEST_LOCATION);
bool found = false;
- for ( size_t i = 0; detector.GetAngleCount(); i++)
+ for(size_t i = 0; detector.GetAngleCount(); i++)
{
- if ( detector.GetAngle(i).first == PanGestureDetector::DIRECTION_LEFT )
+ if(detector.GetAngle(i).first == PanGestureDetector::DIRECTION_LEFT)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
found = true;
break;
}
-
}
- if (!found )
+ if(!found)
{
- tet_printf("%s, angle not added\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ tet_printf("%s, angle not added\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
found = false;
- for( size_t i = 0; i < detector.GetAngleCount(); i++)
+ for(size_t i = 0; i < detector.GetAngleCount(); i++)
{
- if( detector.GetAngle(i).first == PanGestureDetector::DIRECTION_RIGHT )
+ if(detector.GetAngle(i).first == PanGestureDetector::DIRECTION_RIGHT)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
found = true;
break;
}
}
- if(!found )
+ if(!found)
{
- tet_printf("%s, angle not added\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ tet_printf("%s, angle not added\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
// Remove something not in the container.
- detector.RemoveDirection( PanGestureDetector::DIRECTION_UP );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 2u, TEST_LOCATION );
+ detector.RemoveDirection(PanGestureDetector::DIRECTION_UP);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 2u, TEST_LOCATION);
- detector.RemoveDirection( PanGestureDetector::DIRECTION_RIGHT );
- DALI_TEST_EQUALS( detector.GetAngleCount(), 0u, TEST_LOCATION );
+ detector.RemoveDirection(PanGestureDetector::DIRECTION_RIGHT);
+ DALI_TEST_EQUALS(detector.GetAngleCount(), 0u, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(child);
// Render and notify
// Parent detector only requires vertical panning
PanGestureDetector parentDetector = PanGestureDetector::New();
- parentDetector.Attach( parent );
- parentDetector.AddDirection( PanGestureDetector::DIRECTION_VERTICAL, Degree( 30.0f ) );
- SignalData parentData;
+ parentDetector.Attach(parent);
+ parentDetector.AddDirection(PanGestureDetector::DIRECTION_VERTICAL, Degree(30.0f));
+ SignalData parentData;
GestureReceivedFunctor parentFunctor(parentData);
parentDetector.DetectedSignal().Connect(&application, parentFunctor);
// Child detector only requires horizontal panning
PanGestureDetector childDetector = PanGestureDetector::New();
- childDetector.Attach( child );
- childDetector.AddDirection( PanGestureDetector::DIRECTION_HORIZONTAL, Degree( 30.0f ) );
- SignalData childData;
+ childDetector.Attach(child);
+ childDetector.AddDirection(PanGestureDetector::DIRECTION_HORIZONTAL, Degree(30.0f));
+ SignalData childData;
GestureReceivedFunctor childFunctor(childData);
childDetector.DetectedSignal().Connect(&application, childFunctor);
// Generate an Up pan gesture, only parent should receive it.
uint32_t time = 100;
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 20.0f, 4.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(20.0f, 4.0f), time);
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a Right pan gesture, only child should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 36.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(36.0f, 20.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a Down pan gesture, only parent should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 20.0f, 36.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(20.0f, 36.0f), time);
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a Left pan gesture, only child should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 4.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(4.0f, 20.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a pan at -45 degrees, no one should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 9.0f, 31.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(9.0f, 31.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a pan at 45 degrees, no one should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 31.0f, 31.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(31.0f, 31.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
time += TestGetFrameInterval();
parentData.Reset();
childData.Reset();
// Generate a pan at -135 degrees, no one should receive it.
- TestStartPan( application, Vector2( 20.0f, 20.0f ), Vector2( 4.0f, 4.0f ), time );
+ TestStartPan(application, Vector2(20.0f, 20.0f), Vector2(4.0f, 4.0f), time);
- DALI_TEST_EQUALS( false, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, childData.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, childData.functorCalled, TEST_LOCATION);
- TestEndPan( application, Vector2(20.0f, 20.0f), time );
+ TestEndPan(application, Vector2(20.0f, 20.0f), time);
parentData.Reset();
childData.Reset();
END_TEST;
Integration::SetPanGestureSmoothingMode(0);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 1.0f, 1.0f );
- Vector2 position( -14.0f, 1.0f );
- Vector2 direction(Vector2::XAXIS * -5.0f);
+ Vector2 startPosition(1.0f, 1.0f);
+ Vector2 position(-14.0f, 1.0f);
+ Vector2 direction(Vector2::XAXIS * -5.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 47; i++ )
+ for(int i = 0; i < 47; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, startPosition + (direction * PAN_GESTURE_UPDATE_COUNT), 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, startPosition + (direction * PAN_GESTURE_UPDATE_COUNT), 0.1f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, startPosition + (direction * PAN_GESTURE_UPDATE_COUNT), 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, startPosition + (direction * PAN_GESTURE_UPDATE_COUNT), 0.1f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
Integration::SetPanGestureSmoothingMode(1);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 1.0f, 1.0f );
- Vector2 position( -14.0f, 1.0f );
- Vector2 direction(Vector2::XAXIS * -5.0f);
+ Vector2 startPosition(1.0f, 1.0f);
+ Vector2 position(-14.0f, 1.0f);
+ Vector2 direction(Vector2::XAXIS * -5.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 47; i++ )
+ for(int i = 0; i < 47; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
// Take into account resampling done when prediction is off.
- DALI_TEST_EQUALS( constraintData.screenPosition, startPosition + (direction * (PAN_GESTURE_UPDATE_COUNT - 0.25f)), 0.15f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, startPosition + (direction * (PAN_GESTURE_UPDATE_COUNT - 0.25f)), 0.15f, TEST_LOCATION );
+ DALI_TEST_EQUALS(constraintData.screenPosition, startPosition + (direction * (PAN_GESTURE_UPDATE_COUNT - 0.25f)), 0.15f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, startPosition + (direction * (PAN_GESTURE_UPDATE_COUNT - 0.25f)), 0.15f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
Integration::SetPanGestureSmoothingMode(0);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 1.0f, 1.0f );
- Vector2 position( -1.0f, 1.0f );
- Vector2 direction(Vector2::XAXIS * -1.0f);
+ Vector2 startPosition(1.0f, 1.0f);
+ Vector2 position(-1.0f, 1.0f);
+ Vector2 direction(Vector2::XAXIS * -1.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 47; i++ )
+ for(int i = 0; i < 47; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
Integration::SetPanGestureSmoothingMode(1);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 1.0f, 1.0f );
- Vector2 position( -1.0f, 1.0f );
- Vector2 direction(Vector2::XAXIS * -1.0f);
+ Vector2 startPosition(1.0f, 1.0f);
+ Vector2 position(-1.0f, 1.0f);
+ Vector2 direction(Vector2::XAXIS * -1.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 47; i++ )
+ for(int i = 0; i < 47; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, Vector2(1.0f, 1.0f) + (direction * PAN_GESTURE_UPDATE_COUNT), 10.0f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
int UtcDaliPanGesturePredictionSmoothing02(void)
{
TestApplication application;
- Integration::SetPanGesturePredictionMode( 1 );
- Integration::SetPanGestureMaximumPredictionAmount( 1 );
- Integration::SetPanGesturePredictionAmountAdjustment( 2 );
- Integration::SetPanGestureSmoothingMode( 1 );
- Integration::SetPanGestureSmoothingAmount( 0.25f );
+ Integration::SetPanGesturePredictionMode(1);
+ Integration::SetPanGestureMaximumPredictionAmount(1);
+ Integration::SetPanGesturePredictionAmountAdjustment(2);
+ Integration::SetPanGestureSmoothingMode(1);
+ Integration::SetPanGestureSmoothingAmount(0.25f);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 2.0f, 2.0f );
- Vector2 position( 4.0f, 2.0f );
- Vector2 directionX(Vector2::XAXIS);
- Vector2 directionY(Vector2::YAXIS);
+ Vector2 startPosition(2.0f, 2.0f);
+ Vector2 position(4.0f, 2.0f);
+ Vector2 directionX(Vector2::XAXIS);
+ Vector2 directionY(Vector2::YAXIS);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 7; i++ )
+ for(int i = 0; i < 7; i++)
{
position += directionX;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
position += directionX * 10.0f;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- for(int i = 0; i < 2; i++ )
+ for(int i = 0; i < 2; i++)
{
- position += ( directionX * -1.0f );
- TestMovePan( application, position, time );
+ position += (directionX * -1.0f);
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += directionX;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += directionY;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
{
TestApplication application;
- Integration::SetPanGesturePredictionMode( 2 );
- Integration::SetPanGesturePredictionAmount( 57 );
- Integration::SetPanGestureSmoothingMode( 2 );
- Integration::SetPanGestureUseActualTimes( false );
- Integration::SetPanGestureInterpolationTimeRange( 10 );
- Integration::SetPanGestureScalarOnlyPredictionEnabled( false );
- Integration::SetPanGestureTwoPointPredictionEnabled( true );
- Integration::SetPanGestureTwoPointInterpolatePastTime( 42 );
- Integration::SetPanGestureTwoPointVelocityBias( 0.35f );
- Integration::SetPanGestureTwoPointAccelerationBias( 0.10f );
- Integration::SetPanGestureMultitapSmoothingRange( 34 );
+ Integration::SetPanGesturePredictionMode(2);
+ Integration::SetPanGesturePredictionAmount(57);
+ Integration::SetPanGestureSmoothingMode(2);
+ Integration::SetPanGestureUseActualTimes(false);
+ Integration::SetPanGestureInterpolationTimeRange(10);
+ Integration::SetPanGestureScalarOnlyPredictionEnabled(false);
+ Integration::SetPanGestureTwoPointPredictionEnabled(true);
+ Integration::SetPanGestureTwoPointInterpolatePastTime(42);
+ Integration::SetPanGestureTwoPointVelocityBias(0.35f);
+ Integration::SetPanGestureTwoPointAccelerationBias(0.10f);
+ Integration::SetPanGestureMultitapSmoothingRange(34);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 2.0f, 2.0f );
- Vector2 position( -1.0f, 2.0f );
- Vector2 direction(Vector2::XAXIS * -1.0f);
+ Vector2 startPosition(2.0f, 2.0f);
+ Vector2 position(-1.0f, 2.0f);
+ Vector2 direction(Vector2::XAXIS * -1.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 27; i++ )
+ for(int i = 0; i < 27; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
{
TestApplication application;
- Integration::SetPanGesturePredictionMode( 2 );
- Integration::SetPanGestureSmoothingMode( 2 );
- Integration::SetPanGestureUseActualTimes( true );
- Integration::SetPanGestureInterpolationTimeRange( 10 );
- Integration::SetPanGestureScalarOnlyPredictionEnabled( true );
- Integration::SetPanGestureTwoPointPredictionEnabled( true );
- Integration::SetPanGestureTwoPointInterpolatePastTime( 42 );
- Integration::SetPanGestureTwoPointVelocityBias( 0.35f );
- Integration::SetPanGestureTwoPointAccelerationBias( 0.10f );
- Integration::SetPanGestureMultitapSmoothingRange( 34 );
+ Integration::SetPanGesturePredictionMode(2);
+ Integration::SetPanGestureSmoothingMode(2);
+ Integration::SetPanGestureUseActualTimes(true);
+ Integration::SetPanGestureInterpolationTimeRange(10);
+ Integration::SetPanGestureScalarOnlyPredictionEnabled(true);
+ Integration::SetPanGestureTwoPointPredictionEnabled(true);
+ Integration::SetPanGestureTwoPointInterpolatePastTime(42);
+ Integration::SetPanGestureTwoPointVelocityBias(0.35f);
+ Integration::SetPanGestureTwoPointAccelerationBias(0.10f);
+ Integration::SetPanGestureMultitapSmoothingRange(34);
- Integration::EnableProfiling( Integration::PROFILING_TYPE_PAN_GESTURE );
+ Integration::EnableProfiling(Integration::PROFILING_TYPE_PAN_GESTURE);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 2.0f, 2.0f );
- Vector2 position( 17.0f, 2.0f );
- Vector2 direction(Vector2::XAXIS * -1.0f);
+ Vector2 startPosition(2.0f, 2.0f);
+ Vector2 position(17.0f, 2.0f);
+ Vector2 direction(Vector2::XAXIS * -1.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
{
TestApplication application;
- Integration::SetPanGesturePredictionMode( 2 );
- Integration::SetPanGesturePredictionAmount( 57 );
- Integration::SetPanGestureSmoothingMode( 1 );
- Integration::SetPanGestureUseActualTimes( false );
- Integration::SetPanGestureInterpolationTimeRange( 10 );
- Integration::SetPanGestureScalarOnlyPredictionEnabled( true );
- Integration::SetPanGestureTwoPointPredictionEnabled( true );
- Integration::SetPanGestureTwoPointInterpolatePastTime( 42 );
- Integration::SetPanGestureTwoPointVelocityBias( 0.35f );
- Integration::SetPanGestureTwoPointAccelerationBias( 0.10f );
- Integration::SetPanGestureMultitapSmoothingRange( 34 );
+ Integration::SetPanGesturePredictionMode(2);
+ Integration::SetPanGesturePredictionAmount(57);
+ Integration::SetPanGestureSmoothingMode(1);
+ Integration::SetPanGestureUseActualTimes(false);
+ Integration::SetPanGestureInterpolationTimeRange(10);
+ Integration::SetPanGestureScalarOnlyPredictionEnabled(true);
+ Integration::SetPanGestureTwoPointPredictionEnabled(true);
+ Integration::SetPanGestureTwoPointInterpolatePastTime(42);
+ Integration::SetPanGestureTwoPointVelocityBias(0.35f);
+ Integration::SetPanGestureTwoPointAccelerationBias(0.10f);
+ Integration::SetPanGestureMultitapSmoothingRange(34);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 startPosition( 2.0f, 2.0f );
- Vector2 position( 17.0f, 2.0f );
- Vector2 direction(Vector2::XAXIS * -1.0f);
+ Vector2 startPosition(2.0f, 2.0f);
+ Vector2 position(17.0f, 2.0f);
+ Vector2 direction(Vector2::XAXIS * -1.0f);
uint32_t time = 100;
- TestStartPan( application, startPosition, position, time );
+ TestStartPan(application, startPosition, position, time);
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
-
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- for(int i = 0; i < 5; i++ )
+ for(int i = 0; i < 5; i++)
{
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- for(int i = 0; i < 10; i++ )
+ for(int i = 0; i < 10; i++)
{
position += direction;
- TestMovePan( application, position, time );
+ TestMovePan(application, position, time);
time += TestGetFrameInterval();
application.SendNotification();
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
}
- TestEndPan( application, position, time );
+ TestEndPan(application, position, time);
application.Render(TestApplication::DEFAULT_RENDER_INTERVAL);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, Vector2(2.0f, 2.0f) + position, 10.0f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
int UtcDaliPanGestureSetProperties(void)
{
- TestApplication application;
- TestRenderController& renderController( application.GetRenderController() );
+ TestApplication application;
+ TestRenderController& renderController(application.GetRenderController());
Integration::SetPanGesturePredictionMode(0);
Integration::SetPanGestureSmoothingMode(0);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
- Property::Index animatableGestureProperty = detector.RegisterProperty( "Dummy Property", Vector3::ZERO ); // For code coverage
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
+ Property::Index animatableGestureProperty = detector.RegisterProperty("Dummy Property", Vector3::ZERO); // For code coverage
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
- constraint.AddSource( Source( detector, animatableGestureProperty ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
+ constraint.AddSource(Source(detector, animatableGestureProperty));
constraint.Apply();
// Render and notify
application.Render();
renderController.Initialize();
- DALI_TEST_EQUALS( renderController.WasCalled( TestRenderController::RequestUpdateFunc ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderController.WasCalled(TestRenderController::RequestUpdateFunc), false, TEST_LOCATION);
- Vector2 screenPosition( 20.0f, 20.0f );
- Vector2 screenDisplacement( 1.0f, 1.0f );
- Vector2 screenVelocity( 1.3f, 4.0f );
- Vector2 localPosition( 21.0f, 21.0f );
- Vector2 localDisplacement( 0.5f, 0.5f );
- Vector2 localVelocity( 1.5f, 2.5f );
+ Vector2 screenPosition(20.0f, 20.0f);
+ Vector2 screenDisplacement(1.0f, 1.0f);
+ Vector2 screenVelocity(1.3f, 4.0f);
+ Vector2 localPosition(21.0f, 21.0f);
+ Vector2 localDisplacement(0.5f, 0.5f);
+ Vector2 localVelocity(1.5f, 2.5f);
- PanGestureDetector::SetPanGestureProperties( GeneratePan( 1u, GestureState::STARTED, screenPosition, localPosition, screenDisplacement, localDisplacement, screenVelocity, localVelocity ) );
- DALI_TEST_EQUALS( renderController.WasCalled( TestRenderController::RequestUpdateFunc ), true, TEST_LOCATION );
+ PanGestureDetector::SetPanGestureProperties(GeneratePan(1u, GestureState::STARTED, screenPosition, localPosition, screenDisplacement, localDisplacement, screenVelocity, localVelocity));
+ DALI_TEST_EQUALS(renderController.WasCalled(TestRenderController::RequestUpdateFunc), true, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, screenPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, localPosition, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenDisplacement, screenDisplacement, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localDisplacement, localDisplacement, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenVelocity, screenVelocity, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localVelocity, localVelocity, TEST_LOCATION );
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, screenPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, localPosition, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenDisplacement, screenDisplacement, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localDisplacement, localDisplacement, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenVelocity, screenVelocity, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localVelocity, localVelocity, TEST_LOCATION);
constraintData.Reset();
END_TEST;
}
Integration::SetPanGesturePredictionMode(0);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
- Property::Index property = actor.RegisterProperty( "Dummy Property", Vector3::ZERO );
+ Property::Index property = actor.RegisterProperty("Dummy Property", Vector3::ZERO);
ConstraintData constraintData;
- Constraint constraint = Constraint::New<Vector3>( actor, property, PanConstraint( constraintData ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::SCREEN_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_POSITION ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::LOCAL_VELOCITY ) );
- constraint.AddSource( Source( detector, PanGestureDetector::Property::PANNING ) );
+ Constraint constraint = Constraint::New<Vector3>(actor, property, PanConstraint(constraintData));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::SCREEN_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_POSITION));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_DISPLACEMENT));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::LOCAL_VELOCITY));
+ constraint.AddSource(Source(detector, PanGestureDetector::Property::PANNING));
constraint.Apply();
// Render and notify
application.SendNotification();
application.Render();
- Vector2 currentPosition( 20.0f, 4.0f );
+ Vector2 currentPosition(20.0f, 4.0f);
uint32_t time = 100;
- TestStartPan( application, Vector2( 20.0f, 20.0f ), currentPosition, time );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ TestStartPan(application, Vector2(20.0f, 20.0f), currentPosition, time);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- Vector2 screenPosition( 100.0f, 20.0f );
- Vector2 localPosition( 110.0f, 110.0f );
+ Vector2 screenPosition(100.0f, 20.0f);
+ Vector2 localPosition(110.0f, 110.0f);
- PanGestureDetector::SetPanGestureProperties( GeneratePan( 1u, GestureState::STARTED, screenPosition, localPosition ) );
+ PanGestureDetector::SetPanGestureProperties(GeneratePan(1u, GestureState::STARTED, screenPosition, localPosition));
// Render and notify
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( constraintData.called, true, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.screenPosition, currentPosition, 0.1, TEST_LOCATION );
- DALI_TEST_EQUALS( constraintData.localPosition, currentPosition, 0.1f, TEST_LOCATION );
+ DALI_TEST_EQUALS(constraintData.called, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.screenPosition, currentPosition, 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(constraintData.localPosition, currentPosition, 0.1f, TEST_LOCATION);
constraintData.Reset();
END_TEST;
}
int UtcDaliPanGesturePropertyIndices(void)
{
- TestApplication application;
+ TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
Property::IndexContainer indices;
- detector.GetPropertyIndices( indices );
- DALI_TEST_CHECK( indices.Size() );
- DALI_TEST_EQUALS( indices.Size(), detector.GetPropertyCount(), TEST_LOCATION );
+ detector.GetPropertyIndices(indices);
+ DALI_TEST_CHECK(indices.Size());
+ DALI_TEST_EQUALS(indices.Size(), detector.GetPropertyCount(), TEST_LOCATION);
END_TEST;
}
{
struct PropertyStringIndex
{
- const char * const name;
+ const char* const name;
const Property::Index index;
- const Property::Type type;
+ const Property::Type type;
const Property::Value value;
};
const PropertyStringIndex PROPERTY_TABLE[] =
-{
- { "screenPosition", PanGestureDetector::Property::SCREEN_POSITION, Property::VECTOR2, Vector2::ZERO },
- { "screenDisplacement", PanGestureDetector::Property::SCREEN_DISPLACEMENT, Property::VECTOR2, Vector2::ZERO },
- { "screenVelocity", PanGestureDetector::Property::SCREEN_VELOCITY, Property::VECTOR2, Vector2::ZERO },
- { "localPosition", PanGestureDetector::Property::LOCAL_POSITION, Property::VECTOR2, Vector2::ZERO },
- { "localDisplacement", PanGestureDetector::Property::LOCAL_DISPLACEMENT, Property::VECTOR2, Vector2::ZERO },
- { "localVelocity", PanGestureDetector::Property::LOCAL_VELOCITY, Property::VECTOR2, Vector2::ZERO },
- { "panning", PanGestureDetector::Property::PANNING, Property::BOOLEAN, false },
+ {
+ {"screenPosition", PanGestureDetector::Property::SCREEN_POSITION, Property::VECTOR2, Vector2::ZERO},
+ {"screenDisplacement", PanGestureDetector::Property::SCREEN_DISPLACEMENT, Property::VECTOR2, Vector2::ZERO},
+ {"screenVelocity", PanGestureDetector::Property::SCREEN_VELOCITY, Property::VECTOR2, Vector2::ZERO},
+ {"localPosition", PanGestureDetector::Property::LOCAL_POSITION, Property::VECTOR2, Vector2::ZERO},
+ {"localDisplacement", PanGestureDetector::Property::LOCAL_DISPLACEMENT, Property::VECTOR2, Vector2::ZERO},
+ {"localVelocity", PanGestureDetector::Property::LOCAL_VELOCITY, Property::VECTOR2, Vector2::ZERO},
+ {"panning", PanGestureDetector::Property::PANNING, Property::BOOLEAN, false},
};
-const unsigned int PROPERTY_TABLE_COUNT = sizeof( PROPERTY_TABLE ) / sizeof( PROPERTY_TABLE[0] );
+const unsigned int PROPERTY_TABLE_COUNT = sizeof(PROPERTY_TABLE) / sizeof(PROPERTY_TABLE[0]);
} // unnamed namespace
-
int UtcDaliPanGestureProperties(void)
{
- TestApplication application;
+ TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
- for( unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i )
+ for(unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i)
{
- DALI_TEST_EQUALS( detector.GetPropertyName( PROPERTY_TABLE[ i ].index ), std::string( PROPERTY_TABLE[ i ].name ), TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetPropertyIndex( PROPERTY_TABLE[ i ].name ), PROPERTY_TABLE[ i ].index, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.GetPropertyType( PROPERTY_TABLE[ i ].index ), PROPERTY_TABLE[ i ].type, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.IsPropertyWritable( PROPERTY_TABLE[ i ].index ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.IsPropertyAnimatable( PROPERTY_TABLE[ i ].index ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( detector.IsPropertyAConstraintInput( PROPERTY_TABLE[ i ].index ), true, TEST_LOCATION );
- detector.SetProperty( PROPERTY_TABLE[ i ].index, Property::Value() ); // Just for Coverage
+ DALI_TEST_EQUALS(detector.GetPropertyName(PROPERTY_TABLE[i].index), std::string(PROPERTY_TABLE[i].name), TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetPropertyIndex(PROPERTY_TABLE[i].name), PROPERTY_TABLE[i].index, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.GetPropertyType(PROPERTY_TABLE[i].index), PROPERTY_TABLE[i].type, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.IsPropertyWritable(PROPERTY_TABLE[i].index), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.IsPropertyAnimatable(PROPERTY_TABLE[i].index), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(detector.IsPropertyAConstraintInput(PROPERTY_TABLE[i].index), true, TEST_LOCATION);
+ detector.SetProperty(PROPERTY_TABLE[i].index, Property::Value()); // Just for Coverage
}
END_TEST;
int UtcDaliPanGestureGetProperty(void)
{
- TestApplication application;
+ TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
- for( unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i )
+ for(unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i)
{
- if( PROPERTY_TABLE[ i ].type == Property::VECTOR2 )
+ if(PROPERTY_TABLE[i].type == Property::VECTOR2)
{
- bool value = detector.GetProperty( PROPERTY_TABLE[ i ].index ).Get< bool >();
- DALI_TEST_EQUALS( PROPERTY_TABLE[ i ].value.Get< bool >(), value, TEST_LOCATION );
+ bool value = detector.GetProperty(PROPERTY_TABLE[i].index).Get<bool>();
+ DALI_TEST_EQUALS(PROPERTY_TABLE[i].value.Get<bool>(), value, TEST_LOCATION);
}
- else if( PROPERTY_TABLE[ i ].type == Property::BOOLEAN )
+ else if(PROPERTY_TABLE[i].type == Property::BOOLEAN)
{
- Vector2 value = detector.GetProperty( PROPERTY_TABLE[ i ].index ).Get< Vector2 >();
- DALI_TEST_EQUALS( PROPERTY_TABLE[ i ].value.Get< Vector2 >(), value, TEST_LOCATION );
+ Vector2 value = detector.GetProperty(PROPERTY_TABLE[i].index).Get<Vector2>();
+ DALI_TEST_EQUALS(PROPERTY_TABLE[i].value.Get<Vector2>(), value, TEST_LOCATION);
}
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
+ detector.Attach(actor);
// Render and notify
application.SendNotification();
application.Render();
- for( unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i )
+ for(unsigned int i = 0; i < PROPERTY_TABLE_COUNT; ++i)
{
- detector.SetProperty( PROPERTY_TABLE[ i ].index, Property::Value() ); // Just for Coverage
+ detector.SetProperty(PROPERTY_TABLE[i].index, Property::Value()); // Just for Coverage
- if( PROPERTY_TABLE[ i ].type == Property::VECTOR2 )
+ if(PROPERTY_TABLE[i].type == Property::VECTOR2)
{
- bool value = detector.GetProperty( PROPERTY_TABLE[ i ].index ).Get< bool >();
- DALI_TEST_EQUALS( PROPERTY_TABLE[ i ].value.Get< bool >(), value, TEST_LOCATION );
+ bool value = detector.GetProperty(PROPERTY_TABLE[i].index).Get<bool>();
+ DALI_TEST_EQUALS(PROPERTY_TABLE[i].value.Get<bool>(), value, TEST_LOCATION);
}
- else if( PROPERTY_TABLE[ i ].type == Property::BOOLEAN )
+ else if(PROPERTY_TABLE[i].type == Property::BOOLEAN)
{
- Vector2 value = detector.GetProperty( PROPERTY_TABLE[ i ].index ).Get< Vector2 >();
- DALI_TEST_EQUALS( PROPERTY_TABLE[ i ].value.Get< Vector2 >(), value, TEST_LOCATION );
+ Vector2 value = detector.GetProperty(PROPERTY_TABLE[i].index).Get<Vector2>();
+ DALI_TEST_EQUALS(PROPERTY_TABLE[i].value.Get<Vector2>(), value, TEST_LOCATION);
}
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
// Add a layer to overlap the actor
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer );
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer);
layer.RaiseToTop();
// Render and notify
// Emit signals, should receive
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestEndPan( application, Vector2(26.0f, 20.0f), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Set layer to consume all touch
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
// Render and notify
application.SendNotification();
application.Render();
// Emit the same signals again, should not receive
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestEndPan( application, Vector2(26.0f, 20.0f), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
PanGestureDetector detector = PanGestureDetector::New();
- detector.Attach( actor );
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
// Render and notify
application.SendNotification();
// As normal helper function adds intervals between presses we must generate the sequence
// using other helper functions
- TestStartLongPress( application, 10.0f, 20.0f, 100 ); // Used to send a down press event
- TestMovePan( application, Vector2(26.0f, 20.0f), 100 );
- TestMovePan( application, Vector2(26.0f, 20.0f), 100 ); // 2 motions required to trigger
- TestEndPan( application, Vector2(26.0f, 20.0f), 100 );
+ TestStartLongPress(application, 10.0f, 20.0f, 100); // Used to send a down press event
+ TestMovePan(application, Vector2(26.0f, 20.0f), 100);
+ TestMovePan(application, Vector2(26.0f, 20.0f), 100); // 2 motions required to trigger
+ TestEndPan(application, Vector2(26.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- DALI_TEST_CHECK( !std::isinf( data.receivedGesture.GetVelocity().x ) );
- DALI_TEST_CHECK( !std::isinf( data.receivedGesture.GetVelocity().y ) );
- DALI_TEST_CHECK( !std::isinf( data.receivedGesture.GetScreenVelocity().x ) );
- DALI_TEST_CHECK( !std::isinf( data.receivedGesture.GetScreenVelocity().y ) );
+ DALI_TEST_CHECK(!std::isinf(data.receivedGesture.GetVelocity().x));
+ DALI_TEST_CHECK(!std::isinf(data.receivedGesture.GetVelocity().y));
+ DALI_TEST_CHECK(!std::isinf(data.receivedGesture.GetScreenVelocity().x));
+ DALI_TEST_CHECK(!std::isinf(data.receivedGesture.GetScreenVelocity().y));
data.Reset();
data.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
- bool consume = false;
+ bool consume = false;
TouchEventFunctorConsumeSetter touchFunctor(consume);
- actor.TouchedSignal().Connect(&application,touchFunctor);
+ actor.TouchedSignal().Connect(&application, touchFunctor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PanGestureDetector detector = PanGestureDetector::New();
// Start gesture within the actor's area, we should receive the pan as the touch is NOT being consumed
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the gesture within the actor's area, but now the touch consumes thus cancelling the gesture
consume = true;
- TestMovePan( application, Vector2(26.0f, 4.0f), time );
+ TestMovePan(application, Vector2(26.0f, 4.0f), time);
time += TestGetFrameInterval();
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a pan detector
- PanGestureDetector detector = PanGestureDetector::New();
- bool functorCalled = false;
- detector.Attach( actor );
+ PanGestureDetector detector = PanGestureDetector::New();
+ bool functorCalled = false;
+ detector.Attach(actor);
detector.DetectedSignal().Connect(
- &application,
- [&detector, &functorCalled](Actor actor, const PanGesture& pan)
+ &application,
+ [&detector, &functorCalled](Actor actor, const PanGesture& pan) {
+ if(pan.GetState() == GestureState::FINISHED)
{
- if( pan.GetState() == GestureState::FINISHED )
- {
- detector.Detach(actor);
- functorCalled = true;
- }
- });
+ detector.Detach(actor);
+ functorCalled = true;
+ }
+ });
// Render and notify
application.SendNotification();
try
{
uint32_t time = 100;
- TestStartPan( application, Vector2( 10.0f, 20.0f ), Vector2( 26.0f, 20.0f ), time );
- TestEndPan( application, Vector2(26.0f, 20.0f) );
+ TestStartPan(application, Vector2(10.0f, 20.0f), Vector2(26.0f, 20.0f), time);
+ TestEndPan(application, Vector2(26.0f, 20.0f));
- DALI_TEST_CHECK( true ); // No crash, test has passed
+ DALI_TEST_CHECK(true); // No crash, test has passed
DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
}
catch(...)
{
- DALI_TEST_CHECK( false ); // If we crash, the test has failed
+ DALI_TEST_CHECK(false); // If we crash, the test has failed
}
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/input-options.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/input-options.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
struct SignalData
{
SignalData()
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pannedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
PanGesture receivedGesture;
- Actor pannedActor;
+ Actor pannedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const PanGesture& pan)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = pan;
- signalData.pannedActor = actor;
+ signalData.pannedActor = actor;
}
void operator()()
SignalData& signalData;
};
-
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-Integration::TouchEvent GenerateDoubleTouch( PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time )
+Integration::TouchEvent GenerateDoubleTouch(PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( stateA );
- point.SetScreenPosition( screenPositionA );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
- point.SetScreenPosition( screenPositionB );
- point.SetState( stateB);
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(stateA);
+ point.SetScreenPosition(screenPositionA);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
+ point.SetScreenPosition(screenPositionB);
+ point.SetState(stateB);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
-
int UtcDaliPanGestureRecognizerBasicNoAction(void)
{
TestApplication application;
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 60.0f ), 152 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 60.0f), 152));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 25.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 20.0f, 30.0f ), 152 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 25.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(20.0f, 30.0f), 152));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 40.0f ), 155 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 40.0f), 155));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 50.0f ), PointState::DOWN, Vector2( 40.0f, 40.0f ), 153 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 50.0f), PointState::DOWN, Vector2(40.0f, 40.0f), 153));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 50.0f ), 152 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::STATIONARY, Vector2( 20.0f, 50.0f ), 153 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), 154 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 50.0f), 152));
+ application.ProcessEvent(GenerateSingleTouch(PointState::STATIONARY, Vector2(20.0f, 50.0f), 153));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), 154));
application.SendNotification();
detector.SetMinimumTouchesRequired(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 60.0f ), 152 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 60.0f), 152));
application.SendNotification();
detector.SetMinimumTouchesRequired(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 50.0f ), PointState::DOWN, Vector2( 20.0f, 40.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 40.0f, 50.0f ), PointState::MOTION, Vector2( 40.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 50.0f, 50.0f ), PointState::MOTION, Vector2( 50.0f, 40.0f ), 152 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 50.0f), PointState::DOWN, Vector2(20.0f, 40.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(40.0f, 50.0f), PointState::MOTION, Vector2(40.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(50.0f, 50.0f), PointState::MOTION, Vector2(50.0f, 40.0f), 152));
application.SendNotification();
detector.SetMinimumTouchesRequired(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 50.0f ), PointState::DOWN, Vector2( 20.0f, 40.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 40.0f, 50.0f ), PointState::MOTION, Vector2( 40.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 50.0f, 50.0f ), PointState::MOTION, Vector2( 50.0f, 40.0f ), 152 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::STATIONARY, Vector2( 50.0f, 50.0f ), 153 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 50.0f), PointState::DOWN, Vector2(20.0f, 40.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(40.0f, 50.0f), PointState::MOTION, Vector2(40.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(50.0f, 50.0f), PointState::MOTION, Vector2(50.0f, 40.0f), 152));
+ application.ProcessEvent(GenerateSingleTouch(PointState::STATIONARY, Vector2(50.0f, 50.0f), 153));
application.SendNotification();
detector.SetMinimumTouchesRequired(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 50.0f ), PointState::DOWN, Vector2( 20.0f, 40.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 40.0f, 50.0f ), PointState::MOTION, Vector2( 40.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 50.0f, 50.0f ), PointState::MOTION, Vector2( 50.0f, 40.0f ), 152 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::STATIONARY, Vector2( 50.0f, 50.0f ), PointState::UP, Vector2( 50.0f, 40.0f ), 153 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 50.0f), PointState::DOWN, Vector2(20.0f, 40.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(40.0f, 50.0f), PointState::MOTION, Vector2(40.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(50.0f, 50.0f), PointState::MOTION, Vector2(50.0f, 40.0f), 152));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::STATIONARY, Vector2(50.0f, 50.0f), PointState::UP, Vector2(50.0f, 40.0f), 153));
application.SendNotification();
detector.SetMinimumTouchesRequired(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 50.0f ), PointState::DOWN, Vector2( 20.0f, 40.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 40.0f, 50.0f ), PointState::MOTION, Vector2( 40.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 50.0f, 50.0f ), 153 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 50.0f), PointState::DOWN, Vector2(20.0f, 40.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(40.0f, 50.0f), PointState::MOTION, Vector2(40.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(50.0f, 50.0f), 153));
application.SendNotification();
detector.SetMinimumTouchesRequired(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 50.0f ), PointState::DOWN, Vector2( 20.0f, 40.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 40.0f, 50.0f ), PointState::MOTION, Vector2( 40.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 50.0f, 50.0f ), PointState::MOTION, Vector2( 50.0f, 40.0f ), 152 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 60.0f, 50.0f ), PointState::MOTION, Vector2( 60.0f, 40.0f ), 153 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 70.0f, 50.0f ), PointState::MOTION, Vector2( 70.0f, 40.0f ), 154 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 70.0f, 50.0f ), 155 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 50.0f), PointState::DOWN, Vector2(20.0f, 40.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(40.0f, 50.0f), PointState::MOTION, Vector2(40.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(50.0f, 50.0f), PointState::MOTION, Vector2(50.0f, 40.0f), 152));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(60.0f, 50.0f), PointState::MOTION, Vector2(60.0f, 40.0f), 153));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(70.0f, 50.0f), PointState::MOTION, Vector2(70.0f, 40.0f), 154));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(70.0f, 50.0f), 155));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 60.0f ), 152 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 60.0f ), 153 ) ); // Exercise default case in STARTED case. Not sure if realistic
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 65.0f ), 154 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 151));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 60.0f), 152));
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 60.0f), 153)); // Exercise default case in STARTED case. Not sure if realistic
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 65.0f), 154));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 251 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 60.0f ), 352 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 70.0f ), 453 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 80.0f ), 554 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 90.0f ), 655 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 251));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 60.0f), 352));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 70.0f), 453));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 80.0f), 554));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 90.0f), 655));
application.SendNotification();
Integration::SetPanGestureMinimumPanEvents(8);
-
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 251 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 60.0f ), 352 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 70.0f ), 453 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 80.0f ), 554 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 90.0f ), 655 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 251));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 60.0f), 352));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 70.0f), 453));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 80.0f), 554));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 90.0f), 655));
application.SendNotification();
PanGestureDetector detector = PanGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), 251 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 60.0f ), 352 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 70.0f ), 453 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 80.0f ), 554 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 90.0f ), 655 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), 251));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 60.0f), 352));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 70.0f), 453));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 80.0f), 554));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(20.0f, 90.0f), 655));
application.SendNotification();
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
using namespace Dali::Internal;
namespace
{
// Knots fed into Allegro, which generates control points
-static void SetupPath( Dali::Path& path)
+static void SetupPath(Dali::Path& path)
{
- path.AddPoint(Vector3( 30.0, 80.0, 0.0));
- path.AddPoint(Vector3( 70.0, 120.0, 0.0));
+ path.AddPoint(Vector3(30.0, 80.0, 0.0));
+ path.AddPoint(Vector3(70.0, 120.0, 0.0));
path.AddPoint(Vector3(100.0, 100.0, 0.0));
//Control points for first segment
- path.AddControlPoint( Vector3( 39.0, 90.0, 0.0) );
- path.AddControlPoint(Vector3( 56.0, 119.0, 0.0) );
+ path.AddControlPoint(Vector3(39.0, 90.0, 0.0));
+ path.AddControlPoint(Vector3(56.0, 119.0, 0.0));
//Control points for second segment
- path.AddControlPoint(Vector3( 78.0, 120.0, 0.0) );
- path.AddControlPoint(Vector3( 93.0, 104.0, 0.0) );
+ path.AddControlPoint(Vector3(78.0, 120.0, 0.0));
+ path.AddControlPoint(Vector3(93.0, 104.0, 0.0));
}
} // anonymous namespace
TestApplication application;
Dali::Path path = Dali::Path::New();
- path.AddPoint(Vector3( 50.0, 50.0, 0.0));
- path.AddPoint(Vector3(120.0, 70.0, 0.0));
+ path.AddPoint(Vector3(50.0, 50.0, 0.0));
+ path.AddPoint(Vector3(120.0, 70.0, 0.0));
path.AddPoint(Vector3(190.0, 250.0, 0.0));
path.AddPoint(Vector3(260.0, 260.0, 0.0));
path.AddPoint(Vector3(330.0, 220.0, 0.0));
- path.AddPoint(Vector3(400.0, 50.0, 0.0));
+ path.AddPoint(Vector3(400.0, 50.0, 0.0));
- DALI_TEST_EQUALS(path.GetPoint(0), Vector3( 50.0, 50.0, 0.0), TEST_LOCATION);
- DALI_TEST_EQUALS(path.GetPoint(1), Vector3(120.0, 70.0, 0.0), TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetPoint(0), Vector3(50.0, 50.0, 0.0), TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetPoint(1), Vector3(120.0, 70.0, 0.0), TEST_LOCATION);
DALI_TEST_EQUALS(path.GetPoint(2), Vector3(190.0, 250.0, 0.0), TEST_LOCATION);
DALI_TEST_EQUALS(path.GetPoint(3), Vector3(260.0, 260.0, 0.0), TEST_LOCATION);
DALI_TEST_EQUALS(path.GetPoint(4), Vector3(330.0, 220.0, 0.0), TEST_LOCATION);
- DALI_TEST_EQUALS(path.GetPoint(5), Vector3(400.0, 50.0, 0.0), TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetPoint(5), Vector3(400.0, 50.0, 0.0), TEST_LOCATION);
END_TEST;
}
TestApplication application;
Dali::Path path = Dali::Path::New();
- path.AddPoint(Vector3( 50.0, 50.0, 0.0f));
+ path.AddPoint(Vector3(50.0, 50.0, 0.0f));
try
{
path.GetPoint(1);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "index < mPoint.Size()", TEST_LOCATION);
}
END_TEST;
path.GetPoint(0);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "index < mPoint.Size()", TEST_LOCATION);
}
END_TEST;
TestApplication application;
Dali::Path path = Dali::Path::New();
- path.AddControlPoint( Vector3(0.0f, 0.0f, 0.0) );
- path.AddControlPoint( Vector3(108.0f, 57.0f, 0.0) );
+ path.AddControlPoint(Vector3(0.0f, 0.0f, 0.0));
+ path.AddControlPoint(Vector3(108.0f, 57.0f, 0.0));
DALI_TEST_EQUALS(path.GetControlPoint(0), Vector3(0.0f, 0.0f, 0.0f), TEST_LOCATION);
DALI_TEST_EQUALS(path.GetControlPoint(1), Vector3(108.0f, 57.0f, 0.0f), TEST_LOCATION);
TestApplication application;
Dali::Path path = Dali::Path::New();
- path.AddControlPoint(Vector3(0.0f, 0.0f, 0.0) );
- path.AddControlPoint(Vector3(108.0f, 57.0f, 0.0) );
+ path.AddControlPoint(Vector3(0.0f, 0.0f, 0.0));
+ path.AddControlPoint(Vector3(108.0f, 57.0f, 0.0));
try
{
path.GetControlPoint(5);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "index < mControlPoint.Size()", TEST_LOCATION);
}
END_TEST;
path.GetControlPoint(0);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "index < mControlPoint.Size()", TEST_LOCATION);
}
END_TEST;
Dali::Path path = Dali::Path::New();
- path.AddPoint(Vector3( 50.0, 50.0, 0.0));
- path.AddPoint(Vector3(120.0, 70.0, 0.0));
+ path.AddPoint(Vector3(50.0, 50.0, 0.0));
+ path.AddPoint(Vector3(120.0, 70.0, 0.0));
path.AddPoint(Vector3(190.0, 250.0, 0.0));
path.AddPoint(Vector3(260.0, 260.0, 0.0));
path.AddPoint(Vector3(330.0, 220.0, 0.0));
- path.AddPoint(Vector3(400.0, 50.0, 0.0));
+ path.AddPoint(Vector3(400.0, 50.0, 0.0));
path.GenerateControlPoints(0.25);
- DALI_TEST_EQUALS(path.GetControlPoint(0), Vector3( 68.0, 55.0, 0.0), 1.0, TEST_LOCATION);
- DALI_TEST_EQUALS(path.GetControlPoint(1), Vector3(107.0, 58.0, 0.0), 1.0, TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetControlPoint(0), Vector3(68.0, 55.0, 0.0), 1.0, TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetControlPoint(1), Vector3(107.0, 58.0, 0.0), 1.0, TEST_LOCATION);
DALI_TEST_EQUALS(path.GetControlPoint(2), Vector3(156.0, 102.0, 0.0), 1.0, TEST_LOCATION);
DALI_TEST_EQUALS(path.GetControlPoint(3), Vector3(152.0, 220.0, 0.0), 1.0, TEST_LOCATION);
DALI_TEST_EQUALS(path.GetControlPoint(7), Vector3(317.0, 235.0, 0.0), 1.0, TEST_LOCATION);
DALI_TEST_EQUALS(path.GetControlPoint(8), Vector3(360.0, 185.0, 0.0), 1.0, TEST_LOCATION);
- DALI_TEST_EQUALS(path.GetControlPoint(9), Vector3(383.0, 93.0, 0.0), 1.0, TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetControlPoint(9), Vector3(383.0, 93.0, 0.0), 1.0, TEST_LOCATION);
END_TEST;
}
int utcDaliPathGetPointCount(void)
{
TestApplication application;
- Dali::Path path = Dali::Path::New();
+ Dali::Path path = Dali::Path::New();
DALI_TEST_EQUALS(path.GetPointCount(), 0u, TEST_LOCATION);
- path.AddPoint(Vector3( 50.0, 50.0, 0.0));
- path.AddPoint(Vector3(120.0, 70.0, 0.0));
+ path.AddPoint(Vector3(50.0, 50.0, 0.0));
+ path.AddPoint(Vector3(120.0, 70.0, 0.0));
path.AddPoint(Vector3(190.0, 250.0, 0.0));
path.AddPoint(Vector3(260.0, 260.0, 0.0));
DALI_TEST_EQUALS(path.GetPointCount(), 4u, TEST_LOCATION);
path.AddPoint(Vector3(330.0, 220.0, 0.0));
- path.AddPoint(Vector3(400.0, 50.0, 0.0));
+ path.AddPoint(Vector3(400.0, 50.0, 0.0));
DALI_TEST_EQUALS(path.GetPointCount(), 6u, TEST_LOCATION);
END_TEST;
path.GenerateControlPoints(0.25);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "numSegments > 0", TEST_LOCATION);
}
END_TEST;
TestApplication application;
Dali::Path path = Dali::Path::New();
- path.AddPoint(Vector3(400.0, 50.0, 0.0f));
+ path.AddPoint(Vector3(400.0, 50.0, 0.0f));
try
{
path.GenerateControlPoints(0.25);
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "numSegments > 0", TEST_LOCATION);
}
END_TEST;
int UtcDaliPathSample01(void)
{
TestApplication application;
- Dali::Path path = Dali::Path::New();
+ Dali::Path path = Dali::Path::New();
SetupPath(path);
//t = 0
Vector3 position, tangent;
- path.Sample(0.0f, position, tangent );
+ path.Sample(0.0f, position, tangent);
DALI_TEST_EQUALS(position.x, 30.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 80.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
//t = 0.25
- path.Sample(0.25f, position, tangent );
- DALI_TEST_EQUALS(position.x, 48.0f, 2.0f, TEST_LOCATION);
+ path.Sample(0.25f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 48.0f, 2.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 102.0f, 2.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
// t = 0.5
- path.Sample(0.5f, position, tangent );
- DALI_TEST_EQUALS(position.x, 70.0f, TEST_LOCATION);
+ path.Sample(0.5f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 70.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 120.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 1.0f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.0f, 0.1f, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(tangent.x, 1.0f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.0f, 0.1f, TEST_LOCATION);
//t = 0.75
- path.Sample(0.75f, position, tangent );
- DALI_TEST_EQUALS(position.x, 85.0f, 2.0f, TEST_LOCATION);
+ path.Sample(0.75f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 85.0f, 2.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 112.0f, 2.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.7f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, -0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, -0.6f, 0.1f, TEST_LOCATION);
// t = 1
- path.Sample(1.0f, position, tangent );
+ path.Sample(1.0f, position, tangent);
DALI_TEST_EQUALS(position.x, 100.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 100.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.8f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, -0.4f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.8f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, -0.4f, 0.1f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Dali::Path path = Dali::Path::New();
- Handle handle = path;
+ Dali::Path path = Dali::Path::New();
+ Handle handle = path;
SetupPath(path);
Dali::Path path2 = Dali::Path::DownCast(handle);
//t = 0
Vector3 position, tangent;
- path2.Sample(0.0f, position, tangent );
+ path2.Sample(0.0f, position, tangent);
DALI_TEST_EQUALS(position.x, 30.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 80.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
//t = 0.25
- path2.Sample(0.25f, position, tangent );
- DALI_TEST_EQUALS(position.x, 48.0f, 2.0f, TEST_LOCATION);
+ path2.Sample(0.25f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 48.0f, 2.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 102.0f, 2.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
// t = 0.5
- path2.Sample(0.5f, position, tangent );
- DALI_TEST_EQUALS(position.x, 70.0f, TEST_LOCATION);
+ path2.Sample(0.5f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 70.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 120.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 1.0f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.0f, 0.1f, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(tangent.x, 1.0f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.0f, 0.1f, TEST_LOCATION);
//t = 0.75
- path2.Sample(0.75f, position, tangent );
- DALI_TEST_EQUALS(position.x, 85.0f, 2.0f, TEST_LOCATION);
+ path2.Sample(0.75f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 85.0f, 2.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 112.0f, 2.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.7f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, -0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, -0.6f, 0.1f, TEST_LOCATION);
// t = 1
- path2.Sample(1.0f, position, tangent );
+ path2.Sample(1.0f, position, tangent);
DALI_TEST_EQUALS(position.x, 100.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 100.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.8f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, -0.4f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.8f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, -0.4f, 0.1f, TEST_LOCATION);
END_TEST;
}
//t = 0
Vector3 position, tangent;
- path2.Sample(0.0f, position, tangent );
+ path2.Sample(0.0f, position, tangent);
DALI_TEST_EQUALS(position.x, 30.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 80.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
//t = 0.25
- path2.Sample(0.25f, position, tangent );
- DALI_TEST_EQUALS(position.x, 48.0f, 2.0f, TEST_LOCATION);
+ path2.Sample(0.25f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 48.0f, 2.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 102.0f, 2.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.7f, 0.1f, TEST_LOCATION);
// t = 0.5
- path2.Sample(0.5f, position, tangent );
- DALI_TEST_EQUALS(position.x, 70.0f, TEST_LOCATION);
+ path2.Sample(0.5f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 70.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 120.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 1.0f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, 0.0f, 0.1f, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(tangent.x, 1.0f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, 0.0f, 0.1f, TEST_LOCATION);
//t = 0.75
- path2.Sample(0.75f, position, tangent );
- DALI_TEST_EQUALS(position.x, 85.0f, 2.0f, TEST_LOCATION);
+ path2.Sample(0.75f, position, tangent);
+ DALI_TEST_EQUALS(position.x, 85.0f, 2.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 112.0f, 2.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.7f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, -0.6f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.7f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, -0.6f, 0.1f, TEST_LOCATION);
// t = 1
- path2.Sample(1.0f, position, tangent );
+ path2.Sample(1.0f, position, tangent);
DALI_TEST_EQUALS(position.x, 100.0f, TEST_LOCATION);
DALI_TEST_EQUALS(position.y, 100.0f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.x, 0.8f, 0.1f, TEST_LOCATION);
- DALI_TEST_EQUALS(tangent.y, -0.4f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.x, 0.8f, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(tangent.y, -0.4f, 0.1f, TEST_LOCATION);
END_TEST;
}
Dali::Path path = Dali::Path::New();
Dali::Property::Array points;
- points.Add( Vector3( 100.0f, 100.0f, 100.0f ) )
- .Add( Vector3( 200.0f, 200.0f, 200.0f ) )
- .Add( Vector3( 300.0f, 300.0f, 300.0f ) );
- path.SetProperty( Dali::Path::Property::POINTS, points );
+ points.Add(Vector3(100.0f, 100.0f, 100.0f))
+ .Add(Vector3(200.0f, 200.0f, 200.0f))
+ .Add(Vector3(300.0f, 300.0f, 300.0f));
+ path.SetProperty(Dali::Path::Property::POINTS, points);
{
- Property::Value value = path.GetProperty( Dali::Path::Property::POINTS );
+ Property::Value value = path.GetProperty(Dali::Path::Property::POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
{
- Property::Value value = path.GetCurrentProperty( Dali::Path::Property::POINTS );
+ Property::Value value = path.GetCurrentProperty(Dali::Path::Property::POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
Dali::Path path = Dali::Path::New();
Dali::Property::Array points;
- points.Add( Vector3( 0.1f, 0.1f, 0.1f ) )
- .Add( Vector3( 0.2f, 0.2f, 0.2f ) )
- .Add( Vector3( 0.3f, 0.3f, 0.3f ) );
- path.SetProperty( Dali::Path::Property::CONTROL_POINTS, points );
+ points.Add(Vector3(0.1f, 0.1f, 0.1f))
+ .Add(Vector3(0.2f, 0.2f, 0.2f))
+ .Add(Vector3(0.3f, 0.3f, 0.3f));
+ path.SetProperty(Dali::Path::Property::CONTROL_POINTS, points);
{
- Property::Value value = path.GetProperty( Dali::Path::Property::CONTROL_POINTS );
+ Property::Value value = path.GetProperty(Dali::Path::Property::CONTROL_POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
{
- Property::Value value = path.GetCurrentProperty( Dali::Path::Property::CONTROL_POINTS );
+ Property::Value value = path.GetCurrentProperty(Dali::Path::Property::CONTROL_POINTS);
Property::Array* array = value.GetArray();
- DALI_TEST_CHECK( array );
+ DALI_TEST_CHECK(array);
const unsigned int noOfPoints = points.Size();
- for( unsigned int i = 0; i < noOfPoints; ++i )
+ for(unsigned int i = 0; i < noOfPoints; ++i)
{
- DALI_TEST_EQUALS( ( *array )[i].Get< Vector3 >(), points[i].Get< Vector3 >(), TEST_LOCATION );
+ DALI_TEST_EQUALS((*array)[i].Get<Vector3>(), points[i].Get<Vector3>(), TEST_LOCATION);
}
}
Dali::Path path = Dali::Path::New();
- Property::Index index = path.RegisterProperty( "sceneProperty", 0.f );
- DALI_TEST_EQUALS( index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( path.GetProperty< float >( index ), 0.f, TEST_LOCATION );
+ Property::Index index = path.RegisterProperty("sceneProperty", 0.f);
+ DALI_TEST_EQUALS(index, (Property::Index)PROPERTY_CUSTOM_START_INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(path.GetProperty<float>(index), 0.f, TEST_LOCATION);
- path.SetProperty( index, -1 );
- DALI_TEST_EQUALS( path.GetProperty< float >( index ), -1.f, TEST_LOCATION );
+ path.SetProperty(index, -1);
+ DALI_TEST_EQUALS(path.GetProperty<float>(index), -1.f, TEST_LOCATION);
using Dali::Animation;
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( path, index ), 100.f );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(path, index), 100.f);
- DALI_TEST_EQUALS( path.GetProperty< float >( index ), -1.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(path.GetProperty<float>(index), -1.f, TEST_LOCATION);
// Start the animation
animation.Play();
application.SendNotification();
- application.Render( 1000 /* 100% progress */);
- DALI_TEST_EQUALS( path.GetProperty< float >( index ), 100.0f, TEST_LOCATION );
+ application.Render(1000 /* 100% progress */);
+ DALI_TEST_EQUALS(path.GetProperty<float>(index), 100.0f, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Dali::Path path = Dali::Path::New();
- DALI_TEST_CHECK( path );
- DALI_TEST_EQUALS( 1, path.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(path);
+ DALI_TEST_EQUALS(1, path.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- path.AddPoint(Vector3( 50.0, 50.0, 0.0));
- DALI_TEST_EQUALS( path.GetPoint(0), Vector3( 50.0, 50.0, 0.0), TEST_LOCATION );
+ path.AddPoint(Vector3(50.0, 50.0, 0.0));
+ DALI_TEST_EQUALS(path.GetPoint(0), Vector3(50.0, 50.0, 0.0), TEST_LOCATION);
- Dali::Path move = std::move( path );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetPoint(0), Vector3( 50.0, 50.0, 0.0), TEST_LOCATION );
- DALI_TEST_CHECK( !path );
+ Dali::Path move = std::move(path);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetPoint(0), Vector3(50.0, 50.0, 0.0), TEST_LOCATION);
+ DALI_TEST_CHECK(!path);
END_TEST;
}
TestApplication application;
Dali::Path path = Dali::Path::New();
- DALI_TEST_CHECK( path );
- DALI_TEST_EQUALS( 1, path.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(path);
+ DALI_TEST_EQUALS(1, path.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- path.AddPoint(Vector3( 50.0, 50.0, 0.0));
- DALI_TEST_EQUALS( path.GetPoint(0), Vector3( 50.0, 50.0, 0.0), TEST_LOCATION );
+ path.AddPoint(Vector3(50.0, 50.0, 0.0));
+ DALI_TEST_EQUALS(path.GetPoint(0), Vector3(50.0, 50.0, 0.0), TEST_LOCATION);
Dali::Path move;
- move = std::move( path );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetPoint(0), Vector3( 50.0, 50.0, 0.0), TEST_LOCATION );
- DALI_TEST_CHECK( !path );
+ move = std::move(path);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetPoint(0), Vector3(50.0, 50.0, 0.0), TEST_LOCATION);
+ DALI_TEST_CHECK(!path);
END_TEST;
}
int UtcDaliPathAddControlPointNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
Dali::Vector3 arg1;
int UtcDaliPathGetControlPointNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
unsigned long arg1(0u);
int UtcDaliPathGenerateControlPointsNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
float arg1(0.0f);
int UtcDaliPathAddPointNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
Dali::Vector3 arg1;
int UtcDaliPathGetPointNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
unsigned long arg1(0u);
int UtcDaliPathGetPointCountNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
instance.GetPointCount();
int UtcDaliPathSampleNegative(void)
{
TestApplication application;
- Dali::Path instance;
+ Dali::Path instance;
try
{
- float arg1(0.0f);
+ float arg1(0.0f);
Dali::Vector3 arg2;
Dali::Vector3 arg3;
- instance.Sample(arg1,arg2,arg3);
+ instance.Sample(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
#include <test-touch-event-utils.h>
+#include <iostream>
+
using namespace Dali;
void utc_dali_pinch_gesture_detector_startup(void)
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pinchedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
PinchGesture receivedGesture;
- Actor pinchedActor;
+ Actor pinchedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const PinchGesture& pinch)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = pinch;
- signalData.pinchedActor = actor;
+ signalData.pinchedActor = actor;
}
void operator()()
// Functor that removes the gestured actor from stage
struct UnstageActorFunctor : public GestureReceivedFunctor
{
- UnstageActorFunctor( SignalData& data, GestureState& stateToUnstage, Integration::Scene scene )
- : GestureReceivedFunctor( data ),
- stateToUnstage( stateToUnstage ),
- scene( scene )
+ UnstageActorFunctor(SignalData& data, GestureState& stateToUnstage, Integration::Scene scene)
+ : GestureReceivedFunctor(data),
+ stateToUnstage(stateToUnstage),
+ scene(scene)
{
}
- void operator()( Actor actor, const PinchGesture& pinch )
+ void operator()(Actor actor, const PinchGesture& pinch)
{
- GestureReceivedFunctor::operator()( actor, pinch );
+ GestureReceivedFunctor::operator()(actor, pinch);
- if ( pinch.GetState() == stateToUnstage )
+ if(pinch.GetState() == stateToUnstage)
{
- scene.Remove( actor );
+ scene.Remove(actor);
}
}
- GestureState& stateToUnstage;
+ GestureState& stateToUnstage;
Integration::Scene scene;
};
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
{
TestApplication application;
- PinchGestureDetector detector = PinchGestureDetector::New();;
+ PinchGestureDetector detector = PinchGestureDetector::New();
+ ;
- PinchGestureDetector copy( detector );
- DALI_TEST_CHECK( detector );
+ PinchGestureDetector copy(detector);
+ DALI_TEST_CHECK(detector);
END_TEST;
}
{
TestApplication application;
- PinchGestureDetector detector = PinchGestureDetector::New();;
+ PinchGestureDetector detector = PinchGestureDetector::New();
+ ;
PinchGestureDetector assign;
assign = detector;
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(detector);
- DALI_TEST_CHECK( detector == assign );
+ DALI_TEST_CHECK(detector == assign);
END_TEST;
}
// Attach an actor and emit a touch event on the actor to ensure complete line coverage
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
Integration::TouchEvent touchEvent(1);
- Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 20.0f, 20.0f ) );
+ Integration::Point point;
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(20.0f, 20.0f));
touchEvent.AddPoint(point);
application.ProcessEvent(touchEvent);
Integration::Point point2;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 20.0f, 20.0f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(20.0f, 20.0f));
touchEvent.AddPoint(point2);
application.ProcessEvent(touchEvent);
END_TEST;
PinchGestureDetector detector2 = PinchGestureDetector::DownCast(object);
DALI_TEST_CHECK(detector2);
- PinchGestureDetector detector3 = DownCast< PinchGestureDetector >(object);
+ PinchGestureDetector detector3 = DownCast<PinchGestureDetector>(object);
DALI_TEST_CHECK(detector3);
- BaseHandle unInitializedObject;
+ BaseHandle unInitializedObject;
PinchGestureDetector detector4 = PinchGestureDetector::DownCast(unInitializedObject);
DALI_TEST_CHECK(!detector4);
- PinchGestureDetector detector5 = DownCast< PinchGestureDetector >(unInitializedObject);
+ PinchGestureDetector detector5 = DownCast<PinchGestureDetector>(unInitializedObject);
DALI_TEST_CHECK(!detector5);
- GestureDetector detector6 = PinchGestureDetector::New();
+ GestureDetector detector6 = PinchGestureDetector::New();
PinchGestureDetector detector7 = PinchGestureDetector::DownCast(detector6);
DALI_TEST_CHECK(detector7);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do a pinch outside actor's area
- TestStartPinch( application, Vector2( 112.0f, 62.0f ), Vector2( 112.0f, 162.0f ),
- Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ), 100 );
+ TestStartPinch(application, Vector2(112.0f, 62.0f), Vector2(112.0f, 162.0f), Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), 100);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Continue pinch into actor's area - we should still not receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ),
- Vector2( 5.0f, 5.0f ), Vector2( 35.0f, 35.0f ), 200 );
+ TestContinuePinch(application, Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), Vector2(5.0f, 5.0f), Vector2(35.0f, 35.0f), 200);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Stop pinching - we should still not receive the signal
data.Reset();
- TestEndPinch( application, Vector2( 6.0f, 6.0f ), Vector2( 18.0f, 18.0f ),
- Vector2( 10.0f, 8.0f ), Vector2( 14.0f, 16.0f ), 300 );
+ TestEndPinch(application, Vector2(6.0f, 6.0f), Vector2(18.0f, 18.0f), Vector2(10.0f, 8.0f), Vector2(14.0f, 16.0f), 300);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start pan within the actor's area
- TestStartPinch( application, Vector2( 5.0f, 20.0f ), Vector2( 35.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(5.0f, 20.0f), Vector2(35.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.666f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
// Continue the pan within the actor's area - we should still receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 17.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 400 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(17.0f, 20.0f), Vector2(25.0f, 20.0f), 400);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.2666f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
// Pinch Gesture leaves actor's area - we should still receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 17.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 300.0f, 10.0f ), Vector2( 340.0f, 10.0f ), 1000 );
+ TestContinuePinch(application, Vector2(17.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(300.0f, 10.0f), Vector2(340.0f, 10.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(1.333f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
// Gesture ends - we would receive a finished state
data.Reset();
- TestEndPinch( application, Vector2( 300.0f, 10.0f ), Vector2( 340.0f, 10.0f ),
- Vector2( 305.0f, 10.0f ), Vector2( 315.0f, 10.0f ), 1500);
+ TestEndPinch(application, Vector2(300.0f, 10.0f), Vector2(340.0f, 10.0f), Vector2(305.0f, 10.0f), Vector2(315.0f, 10.0f), 1500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.333f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start pinch within the actor's area
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.555f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
// Continue the pinch within the actor's area - we should still receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.277f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
// Gesture ends within actor's area - we would receive a finished state
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.055f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start pinch within the actor's area
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
-
// Continue the pinch within the actor's area - we should still receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
// Ensure we are no longer signalled
data.Reset();
- TestGeneratePinch( application );
+ TestGeneratePinch(application);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start pinch within the actor's area
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the pinch within the actor's area - we should still receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
// Attach a temporary actor to stop detector being removed from PinchGestureProcessor when main actor
// is destroyed.
Actor tempActor = Actor::New();
- tempActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- tempActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
+ tempActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ tempActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.GetScene().Add(tempActor);
detector.Attach(tempActor);
// Actor lifetime is scoped
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
// Start pinch within the actor's area
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the pinch within the actor's area - we should still receive the signal
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// Gesture ends within the area where the actor used to be
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
application.GetScene().Add(actor);
// Render and notify a couple of times
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do an entire pinch, only check finished value
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(0.055f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(160.0f, data.receivedGesture.GetSpeed(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(70.0f, 30.0f), data.receivedGesture.GetLocalCenterPoint(), 0.01f, TEST_LOCATION);
// Rotate actor again and render and notify
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do an entire pinch, only check finished value
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 2100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 2100);
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 3000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 3000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(0.055f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(160.0f, data.receivedGesture.GetSpeed(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(30.0f, 30.0f), data.receivedGesture.GetLocalCenterPoint(), 0.01f, TEST_LOCATION);
// Rotate actor again and render and notify
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(270.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(270.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do an entire pinch, only check finished value
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 4100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 4100);
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 5000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 5000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(0.055f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(160.0f, data.receivedGesture.GetSpeed(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
// Set child to completely cover parent.
// Change rotation of child to be different from parent so that we can check if our local coordinate
// conversion of the parent actor is correct.
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- child.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
parent.Add(child);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do an entire pan, only check finished value - hits child area but parent should still receive it
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, parent == data.pinchedActor, TEST_LOCATION);
DALI_TEST_EQUALS(0.055f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
detector.Detach(parent);
// Do an entire pan, only check finished value
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 2100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 2100);
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 3000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 3000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, child == data.pinchedActor, TEST_LOCATION);
DALI_TEST_EQUALS(0.055f, data.receivedGesture.GetScale(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor first = Actor::New();
- first.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- first.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(first);
Actor second = Actor::New();
- second.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- second.SetProperty( Actor::Property::POSITION_X, 100.0f);
- second.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ second.SetProperty(Actor::Property::POSITION_X, 100.0f);
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(second);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start pinch within second actor's area
- TestStartPinch( application, Vector2( 102.0f, 20.0f ), Vector2( 138.0f, 20.0f ),
- Vector2( 110.0f, 20.0f ), Vector2( 130.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(102.0f, 20.0f), Vector2(138.0f, 20.0f), Vector2(110.0f, 20.0f), Vector2(130.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.pinchedActor, TEST_LOCATION);
// Pinch moves into first actor's area - second actor should receive the pinch
data.Reset();
- TestContinuePinch( application, Vector2( 110.0f, 20.0f ), Vector2( 130.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(110.0f, 20.0f), Vector2(130.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.pinchedActor, TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 119.0f, 20.0f ), Vector2( 121.0f, 20.0f ), 3000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(119.0f, 20.0f), Vector2(121.0f, 20.0f), 3000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start pinch in actor's area
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Pan continues within actor's area
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Actor become invisible - actor should not receive the next pinch
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// Render and notify
application.SendNotification();
// Gesture ends within actor's area
data.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 3000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 3000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.GetScene().Add(actor2);
// Render and notify
application.Render();
// Attach actor to one detector
- SignalData firstData;
+ SignalData firstData;
GestureReceivedFunctor firstFunctor(firstData);
- PinchGestureDetector firstDetector = PinchGestureDetector::New();
+ PinchGestureDetector firstDetector = PinchGestureDetector::New();
firstDetector.Attach(actor);
firstDetector.DetectedSignal().Connect(&application, firstFunctor);
// Attach actor to another detector
- SignalData secondData;
+ SignalData secondData;
GestureReceivedFunctor secondFunctor(secondData);
- PinchGestureDetector secondDetector = PinchGestureDetector::New();
+ PinchGestureDetector secondDetector = PinchGestureDetector::New();
secondDetector.Attach(actor);
secondDetector.DetectedSignal().Connect(&application, secondFunctor);
secondDetector.Attach(actor2);
// Pinch in actor's area - both detector's functors should be called
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
// Pinch continues in actor's area - both detector's functors should be called
firstData.Reset();
secondData.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
firstDetector.Detach(actor);
firstData.Reset();
secondData.Reset();
- TestEndPinch( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
// New pinch on actor, only secondDetector has actor attached
firstData.Reset();
secondData.Reset();
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 1500 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 1500);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
secondDetector.Detach(actor);
firstData.Reset();
secondData.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 2000 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 2000);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(false, secondData.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor1 = Actor::New();
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor1);
- SignalData data1;
+ SignalData data1;
GestureReceivedFunctor functor1(data1);
- PinchGestureDetector detector1 = PinchGestureDetector::New();
+ PinchGestureDetector detector1 = PinchGestureDetector::New();
detector1.Attach(actor1);
detector1.DetectedSignal().Connect(&application, functor1);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
- actor2.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_RIGHT);
application.GetScene().Add(actor2);
- SignalData data2;
+ SignalData data2;
GestureReceivedFunctor functor2(data2);
- PinchGestureDetector detector2 = PinchGestureDetector::New();
+ PinchGestureDetector detector2 = PinchGestureDetector::New();
detector2.Attach(actor2);
detector2.DetectedSignal().Connect(&application, functor2);
application.Render();
// Start pan in actor1's area, only data1 should be set
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data1.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
PinchGestureDetector detector = PinchGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit signals
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
stateToUnstage = GestureState::CONTINUING;
// Emit signals
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
stateToUnstage = GestureState::FINISHED;
// Emit signals
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- tet_result( TET_PASS ); // If we get here then we have handled actor stage removal gracefully.
+ tet_result(TET_PASS); // If we get here then we have handled actor stage removal gracefully.
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Create and add a second actor so that GestureDetector destruction does not come into play.
- Actor dummyActor( Actor::New() );
- dummyActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- dummyActor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- dummyActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ Actor dummyActor(Actor::New());
+ dummyActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(dummyActor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
PinchGestureDetector detector = PinchGestureDetector::New();
detector.Attach(actor);
detector.Attach(dummyActor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Here we are testing a STARTED actor which is removed in the STARTED callback, but then added back
// before we get a continuing state. As we were removed from the stage, even if we're at the same
// position, we should still not be signalled.
// Emit signals
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Here we delete an actor in started, we should not receive any subsequent signalling.
// Emit signals
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 1500 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 1500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestContinuePinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 2000 );
+ TestContinuePinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 2000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 3000);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 3000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
- PinchGestureDetector detector = PinchGestureDetector::New();
+ PinchGestureDetector detector = PinchGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Add a layer to overlap the actor
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer );
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer);
layer.RaiseToTop();
// Render and notify
application.Render();
// Emit signals, should receive
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Set layer to consume all touch
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
// Render and notify
application.SendNotification();
application.Render();
// Emit the same signals again, should not receive
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 1500 );
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 2000);
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 1500);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 2000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
- bool consume = false;
+ bool consume = false;
TouchEventFunctorConsumeSetter touchFunctor(consume);
- actor.TouchedSignal().Connect(&application,touchFunctor);
+ actor.TouchedSignal().Connect(&application, touchFunctor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
PinchGestureDetector detector = PinchGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start gesture within the actor's area, we should receive the pinch as the touch is NOT being consumed
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the gesture within the actor's area, but now the touch consumes thus cancelling the gesture
consume = true;
- TestContinuePinch( application, Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ),
- Vector2( 5.0f, 5.0f ), Vector2( 35.0f, 35.0f ), 200 );
+ TestContinuePinch(application, Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), Vector2(5.0f, 5.0f), Vector2(35.0f, 35.0f), 200);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CANCELLED, data.receivedGesture.GetState(), TEST_LOCATION);
data.Reset();
// Start another pinch, we should not even get the callback this time
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliPinchGestureDisableDetectionDuringPinchN(void)
{
// Crash sometimes occurred when gesture-recognizer was deleted internally during a signal when the attached actor was detached
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- PinchGestureDetector detector = PinchGestureDetector::New();
- bool functorCalled = false;
- detector.Attach( actor );
+ PinchGestureDetector detector = PinchGestureDetector::New();
+ bool functorCalled = false;
+ detector.Attach(actor);
detector.DetectedSignal().Connect(
- &application,
- [&detector, &functorCalled](Actor actor, const PinchGesture& gesture)
+ &application,
+ [&detector, &functorCalled](Actor actor, const PinchGesture& gesture) {
+ if(gesture.GetState() == GestureState::FINISHED)
{
- if( gesture.GetState() == GestureState::FINISHED )
- {
- detector.Detach(actor);
- functorCalled = true;
- }
- });
+ detector.Detach(actor);
+ functorCalled = true;
+ }
+ });
// Render and notify
application.SendNotification();
// Try the gesture, should not crash
try
{
- TestStartPinch( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
- TestContinuePinch( application, Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ),
- Vector2( 5.0f, 5.0f ), Vector2( 35.0f, 35.0f ), 200 );
- TestEndPinch( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
-
- DALI_TEST_CHECK( true ); // No crash, test has passed
+ TestStartPinch(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
+ TestContinuePinch(application, Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), Vector2(5.0f, 5.0f), Vector2(35.0f, 35.0f), 200);
+ TestEndPinch(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
+
+ DALI_TEST_CHECK(true); // No crash, test has passed
DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
}
catch(...)
{
- DALI_TEST_CHECK( false ); // If we crash, the test has failed
+ DALI_TEST_CHECK(false); // If we crash, the test has failed
}
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/input-options.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/input-options.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
struct SignalData
{
SignalData()
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pinchedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
PinchGesture receivedGesture;
- Actor pinchedActor;
+ Actor pinchedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const PinchGesture& pinch)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = pinch;
- signalData.pinchedActor = actor;
+ signalData.pinchedActor = actor;
}
void operator()()
SignalData& signalData;
};
-
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-Integration::TouchEvent GenerateDoubleTouch( PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time )
+Integration::TouchEvent GenerateDoubleTouch(PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( stateA );
- point.SetScreenPosition( screenPositionA );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
- point.SetScreenPosition( screenPositionB );
- point.SetState( stateB);
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(stateA);
+ point.SetScreenPosition(screenPositionA);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
+ point.SetScreenPosition(screenPositionB);
+ point.SetState(stateB);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
-
int UtcDaliPinchGestureRecognizerBasicNoAction(void)
{
TestApplication application;
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::MOTION, Vector2( 20.0f, 74.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 46.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 58.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::MOTION, Vector2(20.0f, 74.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 46.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 58.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 29.0f ), 165 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::MOTION, Vector2( 20.0f, 74.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 46.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 58.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 29.0f), 165));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::MOTION, Vector2(20.0f, 74.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 46.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 58.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::MOTION, Vector2( 20.0f, 74.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::UP, Vector2( 20.0f, 74.0f ), 173 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::DOWN, Vector2( 20.0f, 74.0f ), 178 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 46.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 58.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::MOTION, Vector2(20.0f, 74.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::UP, Vector2(20.0f, 74.0f), 173));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::DOWN, Vector2(20.0f, 74.0f), 178));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 46.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 58.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 100 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 105 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 110 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 25.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 115 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 85.0f ), 120 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 35.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 125 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 75.0f ), 130 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 45.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 135 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 50.0f ), PointState::MOTION, Vector2( 20.0f, 65.0f ), 140 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 60.0f ), 145 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 56.0f ), PointState::UP, Vector2( 20.0f, 60.0f ), 150 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 56.0f ), 155 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 100));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 105));
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 110));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 25.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 115));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 85.0f), 120));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 35.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 125));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 75.0f), 130));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 45.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 135));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 50.0f), PointState::MOTION, Vector2(20.0f, 65.0f), 140));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 60.0f), 145));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 56.0f), PointState::UP, Vector2(20.0f, 60.0f), 150));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 56.0f), 155));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 100 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 105 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 110 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 25.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 115 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 85.0f ), 120 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 35.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 125 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 75.0f ), 130 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 45.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 135 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 50.0f ), PointState::MOTION, Vector2( 20.0f, 65.0f ), 140 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 60.0f ), 145 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 56.0f ), 155 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 100));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 105));
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 110));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 25.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 115));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 85.0f), 120));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 35.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 125));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 75.0f), 130));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 45.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 135));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 50.0f), PointState::MOTION, Vector2(20.0f, 65.0f), 140));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 60.0f), 145));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 56.0f), 155));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 100 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 105 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 110 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 25.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 115 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 85.0f ), 120 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 35.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 125 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::MOTION, Vector2( 20.0f, 77.0f ), 127 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 75.0f ), 130 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 47.0f ), PointState::MOTION, Vector2( 20.0f, 73.0f ), 133 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 45.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 135 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 47.0f ), PointState::MOTION, Vector2( 20.0f, 67.0f ), 137 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 50.0f ), PointState::MOTION, Vector2( 20.0f, 65.0f ), 140 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 53.0f ), PointState::MOTION, Vector2( 20.0f, 63.0f ), 143 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 60.0f ), 145 ) );
-
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 56.0f ), 155 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 100));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 105));
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 110));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 25.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 115));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 85.0f), 120));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 35.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 125));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::MOTION, Vector2(20.0f, 77.0f), 127));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 75.0f), 130));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 47.0f), PointState::MOTION, Vector2(20.0f, 73.0f), 133));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 45.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 135));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 47.0f), PointState::MOTION, Vector2(20.0f, 67.0f), 137));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 50.0f), PointState::MOTION, Vector2(20.0f, 65.0f), 140));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 53.0f), PointState::MOTION, Vector2(20.0f, 63.0f), 143));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 60.0f), 145));
+
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 56.0f), 155));
application.SendNotification();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor2.SetProperty( Actor::Property::POSITION_X, 100.0f);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor2.SetProperty(Actor::Property::POSITION_X, 100.0f);
application.GetScene().Add(actor2);
// Render and notify
PinchGestureDetector detector2 = PinchGestureDetector::New();
detector2.Attach(actor2);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- SignalData data2;
+ SignalData data2;
GestureReceivedFunctor functor2(data2);
detector2.DetectedSignal().Connect(&application, functor2);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 120.0f, 20.0f ), PointState::DOWN, Vector2( 120.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 120.0f, 28.0f ), PointState::MOTION, Vector2( 120.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 120.0f, 37.0f ), PointState::MOTION, Vector2( 120.0f, 74.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 120.0f, 46.0f ), PointState::MOTION, Vector2( 120.0f, 66.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 120.0f, 55.0f ), PointState::MOTION, Vector2( 120.0f, 58.0f ), 190 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, Vector2( 120.0f, 55.0f ), PointState::UP, Vector2( 120.0f, 58.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(120.0f, 20.0f), PointState::DOWN, Vector2(120.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(120.0f, 28.0f), PointState::MOTION, Vector2(120.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(120.0f, 37.0f), PointState::MOTION, Vector2(120.0f, 74.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(120.0f, 46.0f), PointState::MOTION, Vector2(120.0f, 66.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(120.0f, 55.0f), PointState::MOTION, Vector2(120.0f, 58.0f), 190));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, Vector2(120.0f, 55.0f), PointState::UP, Vector2(120.0f, 58.0f), 200));
application.SendNotification();
DALI_TEST_EQUALS(true, actor2 == data2.pinchedActor, TEST_LOCATION);
data2.Reset();
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 250 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 260 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 37.0f ), PointState::MOTION, Vector2( 20.0f, 74.0f ), 270 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 46.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 280 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 58.0f ), 290 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 250));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 260));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 37.0f), PointState::MOTION, Vector2(20.0f, 74.0f), 270));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 46.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 280));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 58.0f), 290));
application.SendNotification();
END_TEST;
}
-
int UtcDaliPinchGestureRecognizerShortDistance01(void)
{
TestApplication application;
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 32.0f ), PointState::MOTION, Vector2( 20.0f, 78.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 34.0f ), PointState::MOTION, Vector2( 20.0f, 76.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 32.0f), PointState::MOTION, Vector2(20.0f, 78.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 34.0f), PointState::MOTION, Vector2(20.0f, 76.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
Integration::SetPinchGestureMinimumDistance(7.0f);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 28.0f ), PointState::MOTION, Vector2( 20.0f, 82.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 32.0f ), PointState::MOTION, Vector2( 20.0f, 78.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 34.0f ), PointState::MOTION, Vector2( 20.0f, 76.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 28.0f), PointState::MOTION, Vector2(20.0f, 82.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 32.0f), PointState::MOTION, Vector2(20.0f, 78.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 34.0f), PointState::MOTION, Vector2(20.0f, 76.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 22.0f ), PointState::MOTION, Vector2( 20.0f, 88.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 24.0f ), PointState::MOTION, Vector2( 20.0f, 86.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 26.0f ), PointState::MOTION, Vector2( 20.0f, 84.0f ), 180 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 22.0f), PointState::MOTION, Vector2(20.0f, 88.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 24.0f), PointState::MOTION, Vector2(20.0f, 86.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 26.0f), PointState::MOTION, Vector2(20.0f, 84.0f), 180));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 38.0f ), PointState::MOTION, Vector2( 20.0f, 72.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 42.0f ), PointState::MOTION, Vector2( 20.0f, 68.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 44.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 38.0f), PointState::MOTION, Vector2(20.0f, 72.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 42.0f), PointState::MOTION, Vector2(20.0f, 68.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 44.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
Integration::SetPinchGestureMinimumDistance(14.0f);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 22.0f ), PointState::MOTION, Vector2( 20.0f, 88.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 24.0f ), PointState::MOTION, Vector2( 20.0f, 86.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 26.0f ), PointState::MOTION, Vector2( 20.0f, 84.0f ), 180 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 22.0f), PointState::MOTION, Vector2(20.0f, 88.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 24.0f), PointState::MOTION, Vector2(20.0f, 86.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 26.0f), PointState::MOTION, Vector2(20.0f, 84.0f), 180));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
Integration::SetPinchGestureMinimumDistance(14.0f);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 38.0f ), PointState::MOTION, Vector2( 20.0f, 72.0f ), 160 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 42.0f ), PointState::MOTION, Vector2( 20.0f, 68.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 44.0f ), PointState::MOTION, Vector2( 20.0f, 66.0f ), 190 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 38.0f), PointState::MOTION, Vector2(20.0f, 72.0f), 160));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 42.0f), PointState::MOTION, Vector2(20.0f, 68.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 44.0f), PointState::MOTION, Vector2(20.0f, 66.0f), 190));
application.SendNotification();
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- detector.Attach( actor );
+ detector.Attach(actor);
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
// Case 1
// 2 touch events make a gesture begin
- Integration::SetPinchGestureMinimumTouchEvents( 2 );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 90.0f, 90.0f ), 160 ) );
+ Integration::SetPinchGestureMinimumTouchEvents(2);
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(90.0f, 90.0f), 160));
- DALI_TEST_EQUALS( GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Case 2
// 4 touch events make a gesture begin
- Integration::SetPinchGestureMinimumTouchEvents( 4 );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 90.0f, 90.0f ), 160 ) );
+ Integration::SetPinchGestureMinimumTouchEvents(4);
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(90.0f, 90.0f), 160));
// Check the gesture is not detected unlike previous case
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
PinchGestureDetector detector = PinchGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- detector.Attach( actor );
+ detector.Attach(actor);
- SignalData data;
- GestureReceivedFunctor functor( data );
- detector.DetectedSignal().Connect( &application, functor );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ detector.DetectedSignal().Connect(&application, functor);
// Case 1
// > 2 touch events make a gesture begin
Integration::SetPinchGestureMinimumTouchEvents(2);
Integration::SetPinchGestureMinimumTouchEventsAfterStart(6);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 90.0f, 90.0f ), 160 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(90.0f, 90.0f), 160));
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 190 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 190));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 200));
// > Test : not enough touch events to make the gesture state "CONTINUING"
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 210 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 220 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 210));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 220));
// > Test : 6 touch events after start make the gesture state "CONTINUING"
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <algorithm>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <algorithm>
+#include <iostream>
using std::max;
using namespace Dali;
-
static const float ROTATION_EPSILON = 0.0001f;
void utc_dali_pixel_startup(void)
static void TestPixelEnumSize(const int size)
{
- DALI_TEST_CHECK( (static_cast<int>( Pixel::LAST_VALID_PIXEL_FORMAT ) - static_cast<int>( Pixel::FIRST_VALID_PIXEL_FORMAT ) + 1 ) == size &&
- "The Pixel::Format enum may have had new formats added. Expand the test cases to include them.");
+ DALI_TEST_CHECK((static_cast<int>(Pixel::LAST_VALID_PIXEL_FORMAT) - static_cast<int>(Pixel::FIRST_VALID_PIXEL_FORMAT) + 1) == size &&
+ "The Pixel::Format enum may have had new formats added. Expand the test cases to include them.");
}
int UtcDaliPixelHasAlpha(void)
tet_infoline("UtcDaliPixelHasAlpha");
- TestPixelEnumSize( 59 );
-
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::INVALID ) == false ); // For completeness
-
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::L8 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGB565 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGB888 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGB8888 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::BGR8888 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::BGR565 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_R11_EAC ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SIGNED_R11_EAC ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RG11_EAC ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SIGNED_RG11_EAC ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGB8_ETC2 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ETC2 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGB8_ETC1 ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGB_PVRTC_4BPPV1 ) == false );
-
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::A8 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::LA88 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGBA5551 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGBA4444 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGBA8888 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::BGRA8888 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::BGRA5551 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::BGRA4444 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA8_ETC2_EAC ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC ) == true );
-
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR ) == true );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR ) == true );
-
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGB16F ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::RGB32F ) == false );
-
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::DEPTH_UNSIGNED_INT ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::DEPTH_FLOAT ) == false );
- DALI_TEST_CHECK( Pixel::HasAlpha( Pixel::DEPTH_STENCIL ) == false );
+ TestPixelEnumSize(59);
+
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::INVALID) == false); // For completeness
+
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::L8) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGB565) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGB888) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGB8888) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::BGR8888) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::BGR565) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_R11_EAC) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SIGNED_R11_EAC) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RG11_EAC) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SIGNED_RG11_EAC) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGB8_ETC2) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ETC2) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGB8_ETC1) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGB_PVRTC_4BPPV1) == false);
+
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::A8) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::LA88) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGBA5551) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGBA4444) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGBA8888) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::BGRA8888) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::BGRA5551) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::BGRA4444) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA8_ETC2_EAC) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC) == true);
+
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR) == true);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR) == true);
+
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGB16F) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::RGB32F) == false);
+
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::DEPTH_UNSIGNED_INT) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::DEPTH_FLOAT) == false);
+ DALI_TEST_CHECK(Pixel::HasAlpha(Pixel::DEPTH_STENCIL) == false);
END_TEST;
}
int UtcDaliPixelHasAlphaN(void)
{
- DALI_TEST_EQUALS( Pixel::HasAlpha( Pixel::Format( 123123123123 ) ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(Pixel::HasAlpha(Pixel::Format(123123123123)), false, TEST_LOCATION);
END_TEST;
}
tet_infoline("UtcDaliPixelGetBytesPerPixel");
// Be sure that the number of cases tested below is correct:
- TestPixelEnumSize( 59 );
+ TestPixelEnumSize(59);
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::INVALID ) == 0 ); // For completeness
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::INVALID) == 0); // For completeness
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::L8 ) == 1 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::A8 ) == 1 );
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::L8) == 1);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::A8) == 1);
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::LA88 ) == 2 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGB565 ) == 2 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGBA5551 ) == 2 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGBA4444 ) == 2 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::BGR565 ) == 2 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::BGRA5551 ) == 2 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::BGRA4444 ) == 2 );
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::LA88) == 2);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGB565) == 2);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGBA5551) == 2);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGBA4444) == 2);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::BGR565) == 2);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::BGRA5551) == 2);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::BGRA4444) == 2);
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGB888 ) == 3 );
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGB888) == 3);
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGB8888 ) == 4 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::BGR8888 ) == 4 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGBA8888 ) == 4 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::BGRA8888 ) == 4 );
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGB8888) == 4);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::BGR8888) == 4);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGBA8888) == 4);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::BGRA8888) == 4);
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::L8 ) == 1 );
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::L8) == 1);
// Compressed formats are marked as 0 bytes per pixel.
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_R11_EAC ) == 0);
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SIGNED_R11_EAC ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RG11_EAC ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SIGNED_RG11_EAC ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGB8_ETC2 ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ETC2 ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGB8_ETC1 ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGB_PVRTC_4BPPV1 ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA8_ETC2_EAC ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR ) == 0 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR ) == 0 );
-
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGB16F ) == 12 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::RGB32F ) == 24 );
-
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::DEPTH_UNSIGNED_INT ) == 4 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::DEPTH_FLOAT ) == 4 );
- DALI_TEST_CHECK( Pixel::GetBytesPerPixel( Pixel::DEPTH_STENCIL ) == 4 );
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_R11_EAC) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SIGNED_R11_EAC) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RG11_EAC) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SIGNED_RG11_EAC) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGB8_ETC2) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ETC2) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGB8_ETC1) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGB_PVRTC_4BPPV1) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA8_ETC2_EAC) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR) == 0);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR) == 0);
+
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGB16F) == 12);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::RGB32F) == 24);
+
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::DEPTH_UNSIGNED_INT) == 4);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::DEPTH_FLOAT) == 4);
+ DALI_TEST_CHECK(Pixel::GetBytesPerPixel(Pixel::DEPTH_STENCIL) == 4);
END_TEST;
}
int UtcDaliPixelGetBytesPerPixelN(void)
{
- DALI_TEST_EQUALS( Pixel::GetBytesPerPixel( Pixel::Format( 123123123123 ) ), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(Pixel::GetBytesPerPixel(Pixel::Format(123123123123)), 0u, TEST_LOCATION);
END_TEST;
}
tet_infoline("UtcDaliPixelGetAlphaOffsetAndMask");
int byteOffset = 0;
- int bitMask = 0;
+ int bitMask = 0;
// Be sure that the number of cases tested below is correct:
- TestPixelEnumSize( 59 );
-
- Pixel::GetAlphaOffsetAndMask( Pixel::INVALID, byteOffset, bitMask ); // For completeness
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
-
- Pixel::GetAlphaOffsetAndMask( Pixel::L8, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::A8, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0xff );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGB888, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGB565, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGB8888, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::BGR8888, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::LA88, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 1 && bitMask == 0xff );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGBA4444, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 1 && bitMask == 0x0f );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGBA5551, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 1 && bitMask == 0x01 );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGBA8888, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 3 && bitMask == 0xff );
- Pixel::GetAlphaOffsetAndMask( Pixel::BGRA8888, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 3 && bitMask == 0xff );
- Pixel::GetAlphaOffsetAndMask( Pixel::BGR565, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::BGRA4444, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 1 && bitMask == 0x0f );
- Pixel::GetAlphaOffsetAndMask( Pixel::BGRA5551, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 1 && bitMask == 0x01 );
+ TestPixelEnumSize(59);
+
+ Pixel::GetAlphaOffsetAndMask(Pixel::INVALID, byteOffset, bitMask); // For completeness
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+
+ Pixel::GetAlphaOffsetAndMask(Pixel::L8, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::A8, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0xff);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGB888, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGB565, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGB8888, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::BGR8888, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::LA88, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 1 && bitMask == 0xff);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGBA4444, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 1 && bitMask == 0x0f);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGBA5551, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 1 && bitMask == 0x01);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGBA8888, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 3 && bitMask == 0xff);
+ Pixel::GetAlphaOffsetAndMask(Pixel::BGRA8888, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 3 && bitMask == 0xff);
+ Pixel::GetAlphaOffsetAndMask(Pixel::BGR565, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::BGRA4444, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 1 && bitMask == 0x0f);
+ Pixel::GetAlphaOffsetAndMask(Pixel::BGRA5551, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 1 && bitMask == 0x01);
// Compressed formats with no meaningful result:
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_R11_EAC, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SIGNED_R11_EAC, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RG11_EAC, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SIGNED_RG11_EAC, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGB8_ETC2, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ETC2, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGB8_ETC1, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGB_PVRTC_4BPPV1, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA8_ETC2_EAC, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
-
- Pixel::GetAlphaOffsetAndMask( Pixel::RGB16F, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::RGB32F, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
-
- Pixel::GetAlphaOffsetAndMask( Pixel::DEPTH_UNSIGNED_INT, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::DEPTH_FLOAT, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
- Pixel::GetAlphaOffsetAndMask( Pixel::DEPTH_STENCIL, byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 0 && bitMask == 0 );
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_R11_EAC, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SIGNED_R11_EAC, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RG11_EAC, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SIGNED_RG11_EAC, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGB8_ETC2, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ETC2, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGB8_ETC1, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGB_PVRTC_4BPPV1, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA8_ETC2_EAC, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGB16F, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::RGB32F, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+
+ Pixel::GetAlphaOffsetAndMask(Pixel::DEPTH_UNSIGNED_INT, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::DEPTH_FLOAT, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
+ Pixel::GetAlphaOffsetAndMask(Pixel::DEPTH_STENCIL, byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 0 && bitMask == 0);
END_TEST;
}
tet_infoline("UtcDaliPixelConvertGlFormat");
unsigned int pixelDataType, internalFormat;
- Dali::Integration::ConvertToGlFormat( Pixel::Format::DEPTH_UNSIGNED_INT, pixelDataType, internalFormat );
- DALI_TEST_CHECK( pixelDataType == GL_UNSIGNED_INT );
- DALI_TEST_CHECK( internalFormat == GL_DEPTH_COMPONENT );
+ Dali::Integration::ConvertToGlFormat(Pixel::Format::DEPTH_UNSIGNED_INT, pixelDataType, internalFormat);
+ DALI_TEST_CHECK(pixelDataType == GL_UNSIGNED_INT);
+ DALI_TEST_CHECK(internalFormat == GL_DEPTH_COMPONENT);
- Dali::Integration::ConvertToGlFormat( Pixel::Format::DEPTH_FLOAT, pixelDataType, internalFormat );
- DALI_TEST_CHECK( pixelDataType == GL_FLOAT );
- DALI_TEST_CHECK( internalFormat == GL_DEPTH_COMPONENT );
+ Dali::Integration::ConvertToGlFormat(Pixel::Format::DEPTH_FLOAT, pixelDataType, internalFormat);
+ DALI_TEST_CHECK(pixelDataType == GL_FLOAT);
+ DALI_TEST_CHECK(internalFormat == GL_DEPTH_COMPONENT);
- Dali::Integration::ConvertToGlFormat( Pixel::Format::DEPTH_STENCIL, pixelDataType, internalFormat );
- DALI_TEST_CHECK( pixelDataType == GL_UNSIGNED_INT_24_8 );
- DALI_TEST_CHECK( internalFormat == GL_DEPTH_STENCIL );
+ Dali::Integration::ConvertToGlFormat(Pixel::Format::DEPTH_STENCIL, pixelDataType, internalFormat);
+ DALI_TEST_CHECK(pixelDataType == GL_UNSIGNED_INT_24_8);
+ DALI_TEST_CHECK(internalFormat == GL_DEPTH_STENCIL);
END_TEST;
}
int UtcDaliPixelGetAlphaOffsetAndMaskN(void)
{
int byteOffset = 200;
- int bitMask = 200;
- Pixel::GetAlphaOffsetAndMask( Pixel::Format( 123123123123 ), byteOffset, bitMask );
- DALI_TEST_CHECK( byteOffset == 200 );
- DALI_TEST_CHECK( bitMask == 200 );
+ int bitMask = 200;
+ Pixel::GetAlphaOffsetAndMask(Pixel::Format(123123123123), byteOffset, bitMask);
+ DALI_TEST_CHECK(byteOffset == 200);
+ DALI_TEST_CHECK(bitMask == 200);
END_TEST;
}
*
*/
-#include <cstdlib>
#include <dali-test-suite-utils.h>
-
-#include <dali/public-api/images/pixel.h>
-#include <dali/public-api/images/pixel-data.h>
#include <dali/public-api/common/dali-vector.h>
+#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/images/pixel.h>
+
+#include <cstdlib>
using namespace Dali;
{
TestApplication application;
- unsigned int width = 10u;
- unsigned int height = 10u;
- unsigned int bufferSize = width*height*Pixel::GetBytesPerPixel( Pixel::RGB888 );
+ unsigned int width = 10u;
+ unsigned int height = 10u;
+ unsigned int bufferSize = width * height * Pixel::GetBytesPerPixel(Pixel::RGB888);
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGB888, PixelData::FREE );
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGB888, PixelData::FREE);
- DALI_TEST_CHECK( pixelData );
- DALI_TEST_CHECK( pixelData.GetWidth() == width );
- DALI_TEST_CHECK( pixelData.GetHeight() == height );
- DALI_TEST_CHECK( pixelData.GetPixelFormat() == Pixel::RGB888 );
+ DALI_TEST_CHECK(pixelData);
+ DALI_TEST_CHECK(pixelData.GetWidth() == width);
+ DALI_TEST_CHECK(pixelData.GetHeight() == height);
+ DALI_TEST_CHECK(pixelData.GetPixelFormat() == Pixel::RGB888);
END_TEST;
}
{
TestApplication application;
- unsigned int width = 10u;
- unsigned int height = 10u;
- unsigned int bufferSize = width*height*Pixel::GetBytesPerPixel( Pixel::L8 );
- unsigned char* buffer = new unsigned char [ bufferSize ];
- buffer[0] = 'a';
+ unsigned int width = 10u;
+ unsigned int height = 10u;
+ unsigned int bufferSize = width * height * Pixel::GetBytesPerPixel(Pixel::L8);
+ unsigned char* buffer = new unsigned char[bufferSize];
+ buffer[0] = 'a';
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY );
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY);
- DALI_TEST_CHECK( pixelData);
- DALI_TEST_CHECK( pixelData.GetWidth() == width );
- DALI_TEST_CHECK( pixelData.GetHeight() == height );
- DALI_TEST_CHECK( pixelData.GetPixelFormat() == Pixel::L8 );
+ DALI_TEST_CHECK(pixelData);
+ DALI_TEST_CHECK(pixelData.GetWidth() == width);
+ DALI_TEST_CHECK(pixelData.GetHeight() == height);
+ DALI_TEST_CHECK(pixelData.GetPixelFormat() == Pixel::L8);
END_TEST;
}
{
TestApplication application;
- unsigned int width = 10u;
- unsigned int height = 10u;
- unsigned int bufferSize = width*height*Pixel::GetBytesPerPixel( Pixel::L8 );
- unsigned char* buffer = new unsigned char [ bufferSize ];
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY );
+ unsigned int width = 10u;
+ unsigned int height = 10u;
+ unsigned int bufferSize = width * height * Pixel::GetBytesPerPixel(Pixel::L8);
+ unsigned char* buffer = new unsigned char[bufferSize];
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY);
PixelData pixelDataCopy(pixelData);
- DALI_TEST_EQUALS( (bool)pixelDataCopy, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)pixelDataCopy, true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- unsigned int width = 10u;
- unsigned int height = 10u;
- unsigned int bufferSize = width*height*Pixel::GetBytesPerPixel( Pixel::L8 );
- unsigned char* buffer = new unsigned char [ bufferSize ];
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY );
+ unsigned int width = 10u;
+ unsigned int height = 10u;
+ unsigned int bufferSize = width * height * Pixel::GetBytesPerPixel(Pixel::L8);
+ unsigned char* buffer = new unsigned char[bufferSize];
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY);
PixelData pixelData2;
- DALI_TEST_EQUALS( (bool)pixelData2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)pixelData2, false, TEST_LOCATION);
pixelData2 = pixelData;
- DALI_TEST_EQUALS( (bool)pixelData2, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)pixelData2, true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- unsigned int width = 10u;
- unsigned int height = 10u;
- unsigned int bufferSize = width*height*Pixel::GetBytesPerPixel( Pixel::L8 );
- unsigned char* buffer = new unsigned char [ bufferSize ];
+ unsigned int width = 10u;
+ unsigned int height = 10u;
+ unsigned int bufferSize = width * height * Pixel::GetBytesPerPixel(Pixel::L8);
+ unsigned char* buffer = new unsigned char[bufferSize];
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY );
- DALI_TEST_CHECK( pixelData );
- DALI_TEST_EQUALS( width, pixelData.GetWidth(), TEST_LOCATION );
- DALI_TEST_EQUALS( height, pixelData.GetHeight(), TEST_LOCATION );
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY);
+ DALI_TEST_CHECK(pixelData);
+ DALI_TEST_EQUALS(width, pixelData.GetWidth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(height, pixelData.GetHeight(), TEST_LOCATION);
- PixelData moved = std::move( pixelData);
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( width, moved.GetWidth(), TEST_LOCATION );
- DALI_TEST_EQUALS( height, moved.GetHeight(), TEST_LOCATION );
- DALI_TEST_CHECK( !pixelData );
+ PixelData moved = std::move(pixelData);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(width, moved.GetWidth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(height, moved.GetHeight(), TEST_LOCATION);
+ DALI_TEST_CHECK(!pixelData);
END_TEST;
}
{
TestApplication application;
- unsigned int width = 10u;
- unsigned int height = 10u;
- unsigned int bufferSize = width*height*Pixel::GetBytesPerPixel( Pixel::L8 );
- unsigned char* buffer = new unsigned char [ bufferSize ];
+ unsigned int width = 10u;
+ unsigned int height = 10u;
+ unsigned int bufferSize = width * height * Pixel::GetBytesPerPixel(Pixel::L8);
+ unsigned char* buffer = new unsigned char[bufferSize];
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY );
- DALI_TEST_CHECK( pixelData );
- DALI_TEST_EQUALS( width, pixelData.GetWidth(), TEST_LOCATION );
- DALI_TEST_EQUALS( height, pixelData.GetHeight(), TEST_LOCATION );
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::L8, PixelData::DELETE_ARRAY);
+ DALI_TEST_CHECK(pixelData);
+ DALI_TEST_EQUALS(width, pixelData.GetWidth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(height, pixelData.GetHeight(), TEST_LOCATION);
PixelData moved;
- moved = std::move( pixelData);
- DALI_TEST_CHECK( moved );
- DALI_TEST_EQUALS( width, moved.GetWidth(), TEST_LOCATION );
- DALI_TEST_EQUALS( height, moved.GetHeight(), TEST_LOCATION );
- DALI_TEST_CHECK( !pixelData );
+ moved = std::move(pixelData);
+ DALI_TEST_CHECK(moved);
+ DALI_TEST_EQUALS(width, moved.GetWidth(), TEST_LOCATION);
+ DALI_TEST_EQUALS(height, moved.GetHeight(), TEST_LOCATION);
+ DALI_TEST_CHECK(!pixelData);
END_TEST;
}
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/core.h>
#include <dali-test-suite-utils.h>
+#include <dali/integration-api/core.h>
#include <dali/integration-api/processor-interface.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
using namespace Dali;
-
class TestProcessor : public Integration::Processor
{
public:
-
TestProcessor()
: processRun(false)
{
bool processRun;
};
-
int UtcDaliCoreProcessorP(void)
{
TestApplication application;
- TestProcessor testProcessor;
+ TestProcessor testProcessor;
Integration::Core& core = application.GetCore();
- core.RegisterProcessor( testProcessor );
+ core.RegisterProcessor(testProcessor);
tet_infoline("Test that the processor has not been executed yet:");
- DALI_TEST_CHECK( testProcessor.processRun == false );
+ DALI_TEST_CHECK(testProcessor.processRun == false);
application.SendNotification();
tet_infoline("Test that the processor has been executed:");
- DALI_TEST_CHECK( testProcessor.processRun );
+ DALI_TEST_CHECK(testProcessor.processRun);
// Clear down for next part of test
testProcessor.processRun = false;
- core.UnregisterProcessor( testProcessor );
+ core.UnregisterProcessor(testProcessor);
application.SendNotification();
tet_infoline("Test that the processor has not been executed again:");
- DALI_TEST_CHECK( testProcessor.processRun == false );
+ DALI_TEST_CHECK(testProcessor.processRun == false);
END_TEST;
}
TestProcessor testProcessor3;
Integration::Core& core = application.GetCore();
- core.RegisterProcessor( testProcessor1 );
+ core.RegisterProcessor(testProcessor1);
tet_infoline("Test that the processor has not been executed yet:");
- DALI_TEST_CHECK( testProcessor1.processRun == false );
+ DALI_TEST_CHECK(testProcessor1.processRun == false);
application.SendNotification();
tet_infoline("Test that the processor has been executed:");
- DALI_TEST_CHECK( testProcessor1.processRun );
+ DALI_TEST_CHECK(testProcessor1.processRun);
// Clear down for next part of test
testProcessor1.processRun = false;
- core.RegisterProcessor( testProcessor2 );
- core.RegisterProcessor( testProcessor3 );
+ core.RegisterProcessor(testProcessor2);
+ core.RegisterProcessor(testProcessor3);
tet_infoline("Test that the processors have not been executed yet:");
- DALI_TEST_CHECK( testProcessor1.processRun == false );
- DALI_TEST_CHECK( testProcessor2.processRun == false );
- DALI_TEST_CHECK( testProcessor3.processRun == false );
+ DALI_TEST_CHECK(testProcessor1.processRun == false);
+ DALI_TEST_CHECK(testProcessor2.processRun == false);
+ DALI_TEST_CHECK(testProcessor3.processRun == false);
application.SendNotification();
tet_infoline("Test that the processors have been executed:");
- DALI_TEST_CHECK( testProcessor1.processRun );
- DALI_TEST_CHECK( testProcessor2.processRun );
- DALI_TEST_CHECK( testProcessor3.processRun );
+ DALI_TEST_CHECK(testProcessor1.processRun);
+ DALI_TEST_CHECK(testProcessor2.processRun);
+ DALI_TEST_CHECK(testProcessor3.processRun);
// Clear down for next part of test
testProcessor2.processRun = false;
- core.UnregisterProcessor( testProcessor2 );
+ core.UnregisterProcessor(testProcessor2);
application.SendNotification();
tet_infoline("Test that the unregistered processor has not been executed again but others have");
- DALI_TEST_CHECK( testProcessor1.processRun );
- DALI_TEST_CHECK( testProcessor2.processRun == false );
- DALI_TEST_CHECK( testProcessor3.processRun );
+ DALI_TEST_CHECK(testProcessor1.processRun);
+ DALI_TEST_CHECK(testProcessor2.processRun == false);
+ DALI_TEST_CHECK(testProcessor3.processRun);
END_TEST;
}
\ No newline at end of file
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
+
+#include <iostream>
#include <string>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
using namespace Dali;
{
Property::Array array;
- DALI_TEST_CHECK( 0 == array.Size() );
+ DALI_TEST_CHECK(0 == array.Size());
- array.PushBack( 1 );
+ array.PushBack(1);
- DALI_TEST_CHECK( 1 == array.Size() );
+ DALI_TEST_CHECK(1 == array.Size());
- DALI_TEST_CHECK( array[0].Get<int>() == 1 );
+ DALI_TEST_CHECK(array[0].Get<int>() == 1);
END_TEST;
}
{
Property::Array array;
- DALI_TEST_CHECK( 0 == array.Size() );
+ DALI_TEST_CHECK(0 == array.Size());
- array.Add( 1 );
+ array.Add(1);
- DALI_TEST_CHECK( 1 == array.Size() );
- DALI_TEST_CHECK( array[0].Get<int>() == 1 );
+ DALI_TEST_CHECK(1 == array.Size());
+ DALI_TEST_CHECK(array[0].Get<int>() == 1);
- array.Add( 2 )
- .Add( 3 )
- .Add( 4.f );
+ array.Add(2)
+ .Add(3)
+ .Add(4.f);
- DALI_TEST_EQUALS( 4u, array.Size(), TEST_LOCATION );
- DALI_TEST_EQUALS( array[1].Get<int>(), 2, TEST_LOCATION );
- DALI_TEST_EQUALS( array[2].Get<int>(), 3, TEST_LOCATION );
- DALI_TEST_EQUALS( array[3].Get<float>(), 4.f, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(4u, array.Size(), TEST_LOCATION);
+ DALI_TEST_EQUALS(array[1].Get<int>(), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(array[2].Get<int>(), 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(array[3].Get<float>(), 4.f, Math::MACHINE_EPSILON_1, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyArrayCapacityP(void)
{
Property::Array array;
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
array.Reserve(3);
- DALI_TEST_CHECK( 3 == array.Capacity() );
+ DALI_TEST_CHECK(3 == array.Capacity());
END_TEST;
}
int UtcDaliPropertyArrayReserveP(void)
{
Property::Array array;
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
array.Reserve(3);
- DALI_TEST_CHECK( 3 == array.Capacity() );
- DALI_TEST_CHECK( 0 == array.Size() );
+ DALI_TEST_CHECK(3 == array.Capacity());
+ DALI_TEST_CHECK(0 == array.Size());
- array.PushBack( 1 );
- array.PushBack( "world" );
- array.PushBack( 3 );
+ array.PushBack(1);
+ array.PushBack("world");
+ array.PushBack(3);
END_TEST;
}
int UtcDaliPropertyArraySizeP(void)
{
Property::Array array;
- DALI_TEST_CHECK( 0 == array.Capacity() );
- DALI_TEST_CHECK( 0 == array.Size() );
+ DALI_TEST_CHECK(0 == array.Capacity());
+ DALI_TEST_CHECK(0 == array.Size());
array.Reserve(3);
- DALI_TEST_CHECK( 3 == array.Capacity() );
- DALI_TEST_CHECK( 0 == array.Size() );
+ DALI_TEST_CHECK(3 == array.Capacity());
+ DALI_TEST_CHECK(0 == array.Size());
- array.PushBack( 1 );
- array.PushBack( "world" );
- array.PushBack( 3 );
+ array.PushBack(1);
+ array.PushBack("world");
+ array.PushBack(3);
- DALI_TEST_CHECK( 3 == array.Size() );
+ DALI_TEST_CHECK(3 == array.Size());
END_TEST;
}
int UtcDaliPropertyArrayCountP(void)
{
Property::Array array;
- DALI_TEST_CHECK( 0 == array.Capacity() );
- DALI_TEST_CHECK( 0 == array.Count() );
+ DALI_TEST_CHECK(0 == array.Capacity());
+ DALI_TEST_CHECK(0 == array.Count());
array.Reserve(3);
- DALI_TEST_CHECK( 3 == array.Capacity() );
- DALI_TEST_CHECK( 0 == array.Count() );
+ DALI_TEST_CHECK(3 == array.Capacity());
+ DALI_TEST_CHECK(0 == array.Count());
- array.PushBack( 1 );
- array.PushBack( "world" );
- array.PushBack( 3 );
+ array.PushBack(1);
+ array.PushBack("world");
+ array.PushBack(3);
- DALI_TEST_CHECK( 3 == array.Count() );
+ DALI_TEST_CHECK(3 == array.Count());
END_TEST;
}
int UtcDaliPropertyArrayEmptyP(void)
{
Property::Array array;
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
array.Reserve(3);
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
- array.PushBack( 1 );
- array.PushBack( "world" );
- array.PushBack( 3 );
+ array.PushBack(1);
+ array.PushBack("world");
+ array.PushBack(3);
- DALI_TEST_CHECK( !array.Empty() );
+ DALI_TEST_CHECK(!array.Empty());
END_TEST;
}
int UtcDaliPropertyArrayClearP(void)
{
Property::Array array;
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
array.Reserve(3);
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
- array.PushBack( 1 );
- array.PushBack( "world" );
- array.PushBack( 3 );
+ array.PushBack(1);
+ array.PushBack("world");
+ array.PushBack(3);
- DALI_TEST_CHECK( !array.Empty() );
+ DALI_TEST_CHECK(!array.Empty());
array.Clear();
- DALI_TEST_CHECK( array.Empty() );
+ DALI_TEST_CHECK(array.Empty());
END_TEST;
}
Property::Array array;
array.Reserve(3);
- array.PushBack( 1 );
- array.PushBack( "world" );
- array.PushBack( 3 );
+ array.PushBack(1);
+ array.PushBack("world");
+ array.PushBack(3);
- DALI_TEST_CHECK( array[0].Get<int>() == 1 );
- DALI_TEST_CHECK( array[1].Get<std::string>() == "world" );
- DALI_TEST_CHECK( array[2].Get<int>() == 3 );
+ DALI_TEST_CHECK(array[0].Get<int>() == 1);
+ DALI_TEST_CHECK(array[1].Get<std::string>() == "world");
+ DALI_TEST_CHECK(array[2].Get<int>() == 3);
END_TEST;
}
Property::Array anArray;
anArray.Reserve(3);
- anArray.PushBack( 1 );
- anArray.PushBack( "world" );
- anArray.PushBack( 3 );
+ anArray.PushBack(1);
+ anArray.PushBack("world");
+ anArray.PushBack(3);
const Property::Array array(anArray);
- DALI_TEST_CHECK( array[0].Get<int>() == 1 );
- DALI_TEST_CHECK( array[1].Get<std::string>() == "world" );
- DALI_TEST_CHECK( array[2].Get<int>() == 3 );
+ DALI_TEST_CHECK(array[0].Get<int>() == 1);
+ DALI_TEST_CHECK(array[1].Get<std::string>() == "world");
+ DALI_TEST_CHECK(array[2].Get<int>() == 3);
END_TEST;
}
Property::Array anArray;
anArray.Reserve(3);
- anArray.PushBack( 1 );
- anArray.PushBack( "world" );
- anArray.PushBack( 3 );
+ anArray.PushBack(1);
+ anArray.PushBack("world");
+ anArray.PushBack(3);
Property::Array array = anArray;
- DALI_TEST_CHECK( array[0].Get<int>() == 1 );
- DALI_TEST_CHECK( array[1].Get<std::string>() == "world" );
- DALI_TEST_CHECK( array[2].Get<int>() == 3 );
+ DALI_TEST_CHECK(array[0].Get<int>() == 1);
+ DALI_TEST_CHECK(array[1].Get<std::string>() == "world");
+ DALI_TEST_CHECK(array[2].Get<int>() == 3);
END_TEST;
}
Property::Array array;
array.Resize(3);
- DALI_TEST_CHECK( array.Count() == 3 );
+ DALI_TEST_CHECK(array.Count() == 3);
array.Resize(5);
- DALI_TEST_CHECK( array.Count() == 5 );
+ DALI_TEST_CHECK(array.Count() == 5);
END_TEST;
}
std::ostringstream oss;
Property::Array array;
- array.PushBack( 0 );
- array.PushBack( 1 );
- array.PushBack( 2 );
+ array.PushBack(0);
+ array.PushBack(1);
+ array.PushBack(2);
oss << array;
- DALI_TEST_EQUALS( oss.str().compare("Array(3) = [0, 1, 2]"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(oss.str().compare("Array(3) = [0, 1, 2]"), 0, TEST_LOCATION);
END_TEST;
}
std::ostringstream oss;
Property::Array array1;
- array1.PushBack( 0 );
- array1.PushBack( 1 );
- array1.PushBack( 2 );
+ array1.PushBack(0);
+ array1.PushBack(1);
+ array1.PushBack(2);
Property::Array array2;
array2.PushBack(array1);
- array2.PushBack( 1 );
- array2.PushBack( 2 );
+ array2.PushBack(1);
+ array2.PushBack(2);
oss << array2;
- DALI_TEST_EQUALS( oss.str().compare("Array(3) = [Array(3) = [0, 1, 2], 1, 2]"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(oss.str().compare("Array(3) = [Array(3) = [0, 1, 2], 1, 2]"), 0, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyArrayCopyConstructor(void)
{
Property::Array array1;
- array1.PushBack( 0 );
- array1.PushBack( 1 );
- array1.PushBack( 2 );
- DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
+ array1.PushBack(0);
+ array1.PushBack(1);
+ array1.PushBack(2);
+ DALI_TEST_EQUALS(3u, array1.Size(), TEST_LOCATION);
- Property::Array array2( array1 );
- DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
+ Property::Array array2(array1);
+ DALI_TEST_EQUALS(3u, array1.Size(), TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, array2.Size(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyArrayAssignmentOperator(void)
{
Property::Array array1;
- array1.PushBack( 0 );
- array1.PushBack( 1 );
- array1.PushBack( 2 );
- DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
+ array1.PushBack(0);
+ array1.PushBack(1);
+ array1.PushBack(2);
+ DALI_TEST_EQUALS(3u, array1.Size(), TEST_LOCATION);
Property::Array array2;
- array2.PushBack( 4 );
- DALI_TEST_EQUALS( 1u, array2.Size(), TEST_LOCATION );
+ array2.PushBack(4);
+ DALI_TEST_EQUALS(1u, array2.Size(), TEST_LOCATION);
array2 = array1;
- DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
+ DALI_TEST_EQUALS(3u, array1.Size(), TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, array2.Size(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyArrayMoveConstructor(void)
{
Property::Array array1;
- array1.PushBack( 0 );
- array1.PushBack( 1 );
- array1.PushBack( 2 );
- DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
+ array1.PushBack(0);
+ array1.PushBack(1);
+ array1.PushBack(2);
+ DALI_TEST_EQUALS(3u, array1.Size(), TEST_LOCATION);
- Property::Array array2( std::move( array1 ) );
- DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
+ Property::Array array2(std::move(array1));
+ DALI_TEST_EQUALS(3u, array2.Size(), TEST_LOCATION);
// Calling any methods on array1 will debug assert
- const char * exceptionMessage = "Cannot use an object previously used as an r-value";
- DALI_TEST_ASSERTION( array1.Count(), exceptionMessage );
- DALI_TEST_ASSERTION( array1.PushBack( Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Count(), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Clear(), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Reserve( 1 ), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Resize( 1 ), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Capacity(), exceptionMessage );
- DALI_TEST_ASSERTION( array1[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( const_cast< const Property::Array& >( array1 )[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( Property::Array temp; array1 = temp, exceptionMessage );
+ const char* exceptionMessage = "Cannot use an object previously used as an r-value";
+ DALI_TEST_ASSERTION(array1.Count(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.PushBack(Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Count(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Clear(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Reserve(1), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Resize(1), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Capacity(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1[0], exceptionMessage);
+ DALI_TEST_ASSERTION(const_cast<const Property::Array&>(array1)[0], exceptionMessage);
+ DALI_TEST_ASSERTION(Property::Array temp; array1 = temp, exceptionMessage);
END_TEST;
}
int UtcDaliPropertyArrayMoveAssignmentOperator(void)
{
Property::Array array1;
- array1.PushBack( 0 );
- array1.PushBack( 1 );
- array1.PushBack( 2 );
- DALI_TEST_EQUALS( 3u, array1.Size(), TEST_LOCATION );
+ array1.PushBack(0);
+ array1.PushBack(1);
+ array1.PushBack(2);
+ DALI_TEST_EQUALS(3u, array1.Size(), TEST_LOCATION);
Property::Array array2;
- array2.PushBack( 4 );
- DALI_TEST_EQUALS( 1u, array2.Size(), TEST_LOCATION );
+ array2.PushBack(4);
+ DALI_TEST_EQUALS(1u, array2.Size(), TEST_LOCATION);
- array2 = std::move( array1 );
- DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION );
+ array2 = std::move(array1);
+ DALI_TEST_EQUALS(3u, array2.Size(), TEST_LOCATION);
// Calling any methods on array1 will debug assert
- const char * exceptionMessage = "Cannot use an object previously used as an r-value";
- DALI_TEST_ASSERTION( array1.Count(), exceptionMessage );
- DALI_TEST_ASSERTION( array1.PushBack( Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Count(), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Clear(), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Reserve( 1 ), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Resize( 1 ), exceptionMessage );
- DALI_TEST_ASSERTION( array1.Capacity(), exceptionMessage );
- DALI_TEST_ASSERTION( array1[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( const_cast< const Property::Array& >( array1 )[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( Property::Array temp; array1 = temp, exceptionMessage );
+ const char* exceptionMessage = "Cannot use an object previously used as an r-value";
+ DALI_TEST_ASSERTION(array1.Count(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.PushBack(Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Count(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Clear(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Reserve(1), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Resize(1), exceptionMessage);
+ DALI_TEST_ASSERTION(array1.Capacity(), exceptionMessage);
+ DALI_TEST_ASSERTION(array1[0], exceptionMessage);
+ DALI_TEST_ASSERTION(const_cast<const Property::Array&>(array1)[0], exceptionMessage);
+ DALI_TEST_ASSERTION(Property::Array temp; array1 = temp, exceptionMessage);
// Self assignemnt
- array2 = std::move( array2 );
- DALI_TEST_EQUALS( 3u, array2.Size(), TEST_LOCATION ); // still works, no debug assert
+ array2 = std::move(array2);
+ DALI_TEST_EQUALS(3u, array2.Size(), TEST_LOCATION); // still works, no debug assert
END_TEST;
}
int UtcDaliPropertyArrayInitializerListConstructor(void)
{
- Property::Array array{ 1, 2, "hello" };
- DALI_TEST_EQUALS( 3u, array.Size(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::INTEGER, array.GetElementAt( 0 ).GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::INTEGER, array.GetElementAt( 1 ).GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( Property::STRING, array.GetElementAt( 2 ).GetType(), TEST_LOCATION );
+ Property::Array array{1, 2, "hello"};
+ DALI_TEST_EQUALS(3u, array.Size(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::INTEGER, array.GetElementAt(0).GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::INTEGER, array.GetElementAt(1).GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(Property::STRING, array.GetElementAt(2).GetType(), TEST_LOCATION);
END_TEST;
}
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
#include <iostream>
#include <string>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
using namespace Dali;
int UtcDaliPropertyMapPopulate(void)
{
Property::Map map;
- DALI_TEST_CHECK( map.Empty() );
-
- map[ "hello" ] = 1;
- map[ 10 ] = "DALi";
- map[ "world" ] = "world";
- map[ 100 ] = 9;
- map[ "world" ] = 3; // same item as line above
- DALI_TEST_CHECK( !map.Empty() ); // Should no longer be empty
- DALI_TEST_CHECK( map.Count() == 4 ); // Should only have four items, not five!!
- DALI_TEST_CHECK( map["hello"].Get<int>() == 1 );
- DALI_TEST_CHECK( map["world"].Get<int>() == 3 );
- DALI_TEST_EQUALS( "DALi", map[ 10 ].Get<std::string>(), TEST_LOCATION );
- DALI_TEST_CHECK( map[100].Get<int>() == 9 );
+ DALI_TEST_CHECK(map.Empty());
+
+ map["hello"] = 1;
+ map[10] = "DALi";
+ map["world"] = "world";
+ map[100] = 9;
+ map["world"] = 3; // same item as line above
+ DALI_TEST_CHECK(!map.Empty()); // Should no longer be empty
+ DALI_TEST_CHECK(map.Count() == 4); // Should only have four items, not five!!
+ DALI_TEST_CHECK(map["hello"].Get<int>() == 1);
+ DALI_TEST_CHECK(map["world"].Get<int>() == 3);
+ DALI_TEST_EQUALS("DALi", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_CHECK(map[100].Get<int>() == 9);
map.Clear();
- DALI_TEST_CHECK( map.Empty() );
+ DALI_TEST_CHECK(map.Empty());
END_TEST;
}
int UtcDaliPropertyMapCopyAndAssignment(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ "world" ] = 2;
- map[ 10 ] = "DALi";
+ map["hello"] = 1;
+ map["world"] = 2;
+ map[10] = "DALi";
Property::Map assignedMap;
- assignedMap[ "foo" ] = 3;
- assignedMap[ 100 ] = 9;
- DALI_TEST_CHECK( assignedMap.Count() == 2 );
+ assignedMap["foo"] = 3;
+ assignedMap[100] = 9;
+ DALI_TEST_CHECK(assignedMap.Count() == 2);
assignedMap = map;
- DALI_TEST_CHECK( assignedMap.Count() == 3 );
+ DALI_TEST_CHECK(assignedMap.Count() == 3);
- Property::Map copiedMap( map );
- DALI_TEST_CHECK( copiedMap.Count() == 3 );
+ Property::Map copiedMap(map);
+ DALI_TEST_CHECK(copiedMap.Count() == 3);
// Self assignment
- DALI_TEST_CHECK( map.Count() == 3 );
+ DALI_TEST_CHECK(map.Count() == 3);
map = map;
- DALI_TEST_CHECK( map.Count() == 3 );
+ DALI_TEST_CHECK(map.Count() == 3);
END_TEST;
}
int UtcDaliPropertyMapMoveConstructor(void)
{
Property::Map map1;
- map1[ "hello" ] = 1;
- map1[ "world" ] = 2;
- map1[ 10 ] = "DALi";
- DALI_TEST_EQUALS( 3u, map1.Count(), TEST_LOCATION );
+ map1["hello"] = 1;
+ map1["world"] = 2;
+ map1[10] = "DALi";
+ DALI_TEST_EQUALS(3u, map1.Count(), TEST_LOCATION);
- Property::Map map2( std::move( map1 ) );
- DALI_TEST_EQUALS( 3u, map2.Count(), TEST_LOCATION );
+ Property::Map map2(std::move(map1));
+ DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION);
// Calling any methods on map1 will debug assert
- const char * exceptionMessage = "Cannot use an object previously used as an r-value";
- DALI_TEST_ASSERTION( map1.Count(), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Empty(), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Insert( (const char *)"key", Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Insert( std::string( "key" ), Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Insert( 0, Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetValue( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetKey( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetKeyAt( 1 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetPair( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetKeyValue( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( (const char *)"key" ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( std::string( "key" ) ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( 0, "key" ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( "key", Property::INTEGER ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( 0, Property::INTEGER ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Clear(), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Merge( Property::Map() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1[ "key" ], exceptionMessage );
- DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ "key" ], exceptionMessage );
- DALI_TEST_ASSERTION( map1[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( Property::Map temp; map1 = temp, exceptionMessage );
+ const char* exceptionMessage = "Cannot use an object previously used as an r-value";
+ DALI_TEST_ASSERTION(map1.Count(), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Empty(), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Insert((const char*)"key", Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Insert(std::string("key"), Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Insert(0, Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetValue(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetKey(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetKeyAt(1), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetPair(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetKeyValue(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find((const char*)"key"), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(std::string("key")), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(0, "key"), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find("key", Property::INTEGER), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(0, Property::INTEGER), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Clear(), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Merge(Property::Map()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1["key"], exceptionMessage);
+ DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)["key"], exceptionMessage);
+ DALI_TEST_ASSERTION(map1[0], exceptionMessage);
+ DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)[0], exceptionMessage);
+ DALI_TEST_ASSERTION(Property::Map temp; map1 = temp, exceptionMessage);
END_TEST;
}
int UtcDaliPropertyMapMoveAssignmentOperator(void)
{
Property::Map map1;
- map1[ "hello" ] = 1;
- map1[ "world" ] = 2;
- map1[ 10 ] = "DALi";
- DALI_TEST_EQUALS( 3u, map1.Count(), TEST_LOCATION );
+ map1["hello"] = 1;
+ map1["world"] = 2;
+ map1[10] = "DALi";
+ DALI_TEST_EQUALS(3u, map1.Count(), TEST_LOCATION);
Property::Map map2;
- map2[ 10 ] = "DALi again";
- DALI_TEST_EQUALS( 1u, map2.Count(), TEST_LOCATION );
+ map2[10] = "DALi again";
+ DALI_TEST_EQUALS(1u, map2.Count(), TEST_LOCATION);
- map2 = std::move( map1 );
- DALI_TEST_EQUALS( 3u, map2.Count(), TEST_LOCATION );
+ map2 = std::move(map1);
+ DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION);
// Calling any methods on map1 will debug assert
- const char * exceptionMessage = "Cannot use an object previously used as an r-value";
- DALI_TEST_ASSERTION( map1.Count(), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Empty(), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Insert( (const char *)"key", Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Insert( std::string( "key" ), Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Insert( 0, Property::Value() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetValue( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetKey( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetKeyAt( 1 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetPair( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.GetKeyValue( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( (const char *)"key" ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( std::string( "key" ) ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( 0 ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( 0, "key" ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( "key", Property::INTEGER ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Find( 0, Property::INTEGER ), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Clear(), exceptionMessage );
- DALI_TEST_ASSERTION( map1.Merge( Property::Map() ), exceptionMessage );
- DALI_TEST_ASSERTION( map1[ "key" ], exceptionMessage );
- DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ "key" ], exceptionMessage );
- DALI_TEST_ASSERTION( map1[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( const_cast< const Property::Map& >( map1 )[ 0 ], exceptionMessage );
- DALI_TEST_ASSERTION( Property::Map temp; map1 = temp, exceptionMessage );
+ const char* exceptionMessage = "Cannot use an object previously used as an r-value";
+ DALI_TEST_ASSERTION(map1.Count(), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Empty(), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Insert((const char*)"key", Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Insert(std::string("key"), Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Insert(0, Property::Value()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetValue(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetKey(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetKeyAt(1), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetPair(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.GetKeyValue(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find((const char*)"key"), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(std::string("key")), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(0), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(0, "key"), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find("key", Property::INTEGER), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Find(0, Property::INTEGER), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Clear(), exceptionMessage);
+ DALI_TEST_ASSERTION(map1.Merge(Property::Map()), exceptionMessage);
+ DALI_TEST_ASSERTION(map1["key"], exceptionMessage);
+ DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)["key"], exceptionMessage);
+ DALI_TEST_ASSERTION(map1[0], exceptionMessage);
+ DALI_TEST_ASSERTION(const_cast<const Property::Map&>(map1)[0], exceptionMessage);
+ DALI_TEST_ASSERTION(Property::Map temp; map1 = temp, exceptionMessage);
// Self assignment
- map2 = std::move( map2 );
- DALI_TEST_EQUALS( 3u, map2.Count(), TEST_LOCATION ); // No debug assert as nothing should happen
+ map2 = std::move(map2);
+ DALI_TEST_EQUALS(3u, map2.Count(), TEST_LOCATION); // No debug assert as nothing should happen
END_TEST;
}
int UtcDaliPropertyMapConstOperator(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ 10 ] = "DALi";
- map[ "world" ] = 2;
- DALI_TEST_CHECK( map.Count() == 3 );
+ map["hello"] = 1;
+ map[10] = "DALi";
+ map["world"] = 2;
+ DALI_TEST_CHECK(map.Count() == 3);
- const Property::Map& constMap( map );
- DALI_TEST_CHECK( constMap[ "world" ].Get<int>() == 2 );
- DALI_TEST_CHECK( constMap.Count() == 3 ); // Ensure count hasn't gone up
+ const Property::Map& constMap(map);
+ DALI_TEST_CHECK(constMap["world"].Get<int>() == 2);
+ DALI_TEST_CHECK(constMap.Count() == 3); // Ensure count hasn't gone up
- DALI_TEST_EQUALS( "DALi", map[ 10 ].Get<std::string>(), TEST_LOCATION );
- DALI_TEST_CHECK( constMap.Count() == 3 ); // Ensure count hasn't gone up
+ DALI_TEST_EQUALS("DALi", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_CHECK(constMap.Count() == 3); // Ensure count hasn't gone up
// Invalid Key
try
{
- constMap[ "invalidKey" ];
- tet_result( TET_FAIL );
+ constMap["invalidKey"];
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "! \"Invalid Key\"", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "!\"Invalid Key\"", TEST_LOCATION);
}
END_TEST;
int UtcDaliPropertyMapGetValue(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ "world" ] = 2;
- map[ Actor::Property::COLOR ] = Color::MAGENTA;
+ map["hello"] = 1;
+ map["world"] = 2;
+ map[Actor::Property::COLOR] = Color::MAGENTA;
- Property::Value& value = map.GetValue( 0 );
- DALI_TEST_CHECK( value.Get<int>() == 1 );
+ Property::Value& value = map.GetValue(0);
+ DALI_TEST_CHECK(value.Get<int>() == 1);
value = 10; // Allows the actual changing of the value as we have a ref
- DALI_TEST_CHECK( map[ "hello" ].Get<int>() == 10 );
+ DALI_TEST_CHECK(map["hello"].Get<int>() == 10);
- Property::Value& value2 = map.GetValue( 2 );
- DALI_TEST_CHECK( value2.Get<Vector4>() == Color::MAGENTA );
+ Property::Value& value2 = map.GetValue(2);
+ DALI_TEST_CHECK(value2.Get<Vector4>() == Color::MAGENTA);
value2 = Color::CYAN;
- DALI_TEST_EQUALS( map[ Actor::Property::COLOR].Get<Vector4>(), Color::CYAN, TEST_LOCATION);
+ DALI_TEST_EQUALS(map[Actor::Property::COLOR].Get<Vector4>(), Color::CYAN, TEST_LOCATION);
// Out of bounds
try
{
- map.GetValue( 3 );
- tet_result( TET_FAIL );
+ map.GetValue(3);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
END_TEST;
int UtcDaliPropertyMapGetKey(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ "world" ] = 2;
- map[ Actor::Property::COLOR ] = Color::MAGENTA;
+ map["hello"] = 1;
+ map["world"] = 2;
+ map[Actor::Property::COLOR] = Color::MAGENTA;
- DALI_TEST_CHECK( map.GetKey( 0 ) == "hello" );
- DALI_TEST_CHECK( map.GetKey( 1 ) == "world" );
+ DALI_TEST_CHECK(map.GetKey(0) == "hello");
+ DALI_TEST_CHECK(map.GetKey(1) == "world");
// Wrong type
try
{
- map.GetKey( 2 );
- tet_result( TET_FAIL );
+ map.GetKey(2);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
// Out of bounds
try
{
- map.GetKey( 3 );
- tet_result( TET_FAIL );
+ map.GetKey(3);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliPropertyMapGetKeyAt(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ "world" ] = 2;
- map[ Actor::Property::COLOR ] = Color::MAGENTA;
+ map["hello"] = 1;
+ map["world"] = 2;
+ map[Actor::Property::COLOR] = Color::MAGENTA;
- DALI_TEST_CHECK( map.GetKeyAt( 0 ) == "hello" );
- DALI_TEST_CHECK( map.GetKeyAt( 1 ) == "world" );
- DALI_TEST_CHECK( map.GetKeyAt( 2 ) == Actor::Property::COLOR );
+ DALI_TEST_CHECK(map.GetKeyAt(0) == "hello");
+ DALI_TEST_CHECK(map.GetKeyAt(1) == "world");
+ DALI_TEST_CHECK(map.GetKeyAt(2) == Actor::Property::COLOR);
// Out of bounds
try
{
- map.GetKey( 3 );
- tet_result( TET_FAIL );
+ map.GetKey(3);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
END_TEST;
int UtcDaliPropertyMapGetPair(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ "world" ] = 2;
- map[ Actor::Property::COLOR ] = Color::MAGENTA;
+ map["hello"] = 1;
+ map["world"] = 2;
+ map[Actor::Property::COLOR] = Color::MAGENTA;
- DALI_TEST_CHECK( map.GetPair( 0 ).first == "hello" );
- DALI_TEST_CHECK( map.GetPair( 0 ).second.Get< int >() == 1 );
- DALI_TEST_CHECK( map.GetPair( 1 ).first == "world" );
- DALI_TEST_CHECK( map.GetPair( 1 ).second.Get< int >() == 2 );
+ DALI_TEST_CHECK(map.GetPair(0).first == "hello");
+ DALI_TEST_CHECK(map.GetPair(0).second.Get<int>() == 1);
+ DALI_TEST_CHECK(map.GetPair(1).first == "world");
+ DALI_TEST_CHECK(map.GetPair(1).second.Get<int>() == 2);
// Wrong Type
try
{
- map.GetPair( 2 );
- tet_result( TET_FAIL );
+ map.GetPair(2);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
// Out of bounds
try
{
- map.GetPair( 3 );
- tet_result( TET_FAIL );
+ map.GetPair(3);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
END_TEST;
int UtcDaliPropertyMapGetKeyValue(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ "world" ] = 2;
- map[ Actor::Property::COLOR ] = Color::MAGENTA;
+ map["hello"] = 1;
+ map["world"] = 2;
+ map[Actor::Property::COLOR] = Color::MAGENTA;
- DALI_TEST_CHECK( map.GetKeyValue( 0 ).first == "hello" );
- DALI_TEST_CHECK( map.GetKeyValue( 0 ).second.Get< int >() == 1 );
- DALI_TEST_CHECK( map.GetKeyValue( 1 ).first == "world" );
- DALI_TEST_CHECK( map.GetKeyValue( 1 ).second.Get< int >() == 2 );
- DALI_TEST_CHECK( map.GetKeyValue( 2 ).first == Actor::Property::COLOR );
- DALI_TEST_CHECK( map.GetKeyValue( 2 ).second.Get< Vector4 >() == Color::MAGENTA );
+ DALI_TEST_CHECK(map.GetKeyValue(0).first == "hello");
+ DALI_TEST_CHECK(map.GetKeyValue(0).second.Get<int>() == 1);
+ DALI_TEST_CHECK(map.GetKeyValue(1).first == "world");
+ DALI_TEST_CHECK(map.GetKeyValue(1).second.Get<int>() == 2);
+ DALI_TEST_CHECK(map.GetKeyValue(2).first == Actor::Property::COLOR);
+ DALI_TEST_CHECK(map.GetKeyValue(2).second.Get<Vector4>() == Color::MAGENTA);
// Out of bounds
try
{
- map.GetPair( 3 );
- tet_result( TET_FAIL );
+ map.GetPair(3);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "position", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "position", TEST_LOCATION);
}
END_TEST;
int UtcDaliPropertyMapFind(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ 10 ] = "DALi";
- map[ "world" ] = 2;
- map[ 100 ] = 9;
+ map["hello"] = 1;
+ map[10] = "DALi";
+ map["world"] = 2;
+ map[100] = 9;
Property::Value* value = NULL;
- value = map.Find( "hello" );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 1 );
+ value = map.Find("hello");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 1);
const std::string world("world");
- value = map.Find( world );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 2 );
+ value = map.Find(world);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 2);
- value = map.Find( 100 );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 9 );
+ value = map.Find(100);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 9);
- value = map.Find( 10, Property::STRING );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
+ value = map.Find(10, Property::STRING);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
- value = map.Find( 10, Property::INTEGER );
- DALI_TEST_CHECK( value == NULL );
+ value = map.Find(10, Property::INTEGER);
+ DALI_TEST_CHECK(value == NULL);
- value = map.Find( "invalidKey" );
- DALI_TEST_CHECK( !value );
+ value = map.Find("invalidKey");
+ DALI_TEST_CHECK(!value);
END_TEST;
}
int UtcDaliPropertyMapFindIndexThenString(void)
{
// Define the valid keys and values to test with.
- std::string stringKeyValid = "bar";
+ std::string stringKeyValid = "bar";
std::string stringKeyInvalid = "aardvark";
- int indexKeyValid = 100;
- int indexKeyInvalid = 101;
+ int indexKeyValid = 100;
+ int indexKeyInvalid = 101;
// Define invalid key and value to test with.
std::string stringValueValid = "DALi";
- int indexValueValid = 3;
+ int indexValueValid = 3;
// Set up a property map containing the valid keys and values defined above.
Property::Map map;
- map[ "foo" ] = 1;
- map[ 10 ] = "string";
- map[ stringKeyValid ] = stringValueValid;
- map[ indexKeyValid ] = indexValueValid;
+ map["foo"] = 1;
+ map[10] = "string";
+ map[stringKeyValid] = stringValueValid;
+ map[indexKeyValid] = indexValueValid;
Property::Value* value = NULL;
// TEST: If both index and string are valid, the Property::Value of the index is returned.
- value = map.Find( indexKeyValid, stringKeyValid );
-
- DALI_TEST_EQUALS( value->Get<int>(), indexValueValid, TEST_LOCATION );
+ value = map.Find(indexKeyValid, stringKeyValid);
+ DALI_TEST_EQUALS(value->Get<int>(), indexValueValid, TEST_LOCATION);
// TEST: If only the index is valid, the Property::Value of the index is returned.
- value = map.Find( indexKeyValid, stringKeyInvalid );
-
- DALI_TEST_EQUALS( value->Get<int>(), indexValueValid, TEST_LOCATION );
+ value = map.Find(indexKeyValid, stringKeyInvalid);
+ DALI_TEST_EQUALS(value->Get<int>(), indexValueValid, TEST_LOCATION);
// TEST: If only the string is valid, the Property::Value of the string is returned.
- value = map.Find( indexKeyInvalid, stringKeyValid );
-
- DALI_TEST_EQUALS( value->Get<std::string>(), stringValueValid, TEST_LOCATION );
+ value = map.Find(indexKeyInvalid, stringKeyValid);
+ DALI_TEST_EQUALS(value->Get<std::string>(), stringValueValid, TEST_LOCATION);
// TEST: If neither the index or string are valid, then a NULL pointer is returned.
- value = map.Find( indexKeyInvalid, stringKeyInvalid );
+ value = map.Find(indexKeyInvalid, stringKeyInvalid);
- DALI_TEST_CHECK( value == NULL );
+ DALI_TEST_CHECK(value == NULL);
END_TEST;
}
int UtcDaliPropertyMapOperatorIndex(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ 10 ] = "DALi";
- map[ "world" ] = 2;
- map[ 100 ] = 9;
+ map["hello"] = 1;
+ map[10] = "DALi";
+ map["world"] = 2;
+ map[100] = 9;
- const Property::Map map2 = map;
+ const Property::Map map2 = map;
const Property::Value& value10 = map2[10];
- DALI_TEST_EQUALS( value10.Get<std::string>(), "DALi", TEST_LOCATION );
+ DALI_TEST_EQUALS(value10.Get<std::string>(), "DALi", TEST_LOCATION);
const Property::Value& value100 = map2[100];
- DALI_TEST_EQUALS( value100.Get<int>(), 9, TEST_LOCATION );
+ DALI_TEST_EQUALS(value100.Get<int>(), 9, TEST_LOCATION);
const Property::Value& valueHello = map2["hello"];
- DALI_TEST_EQUALS( valueHello.Get<int>(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(valueHello.Get<int>(), 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyMapInsertP(void)
{
Property::Map map;
- DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
- map.Insert( "foo", "bar");
- DALI_TEST_EQUALS( 1u, map.Count(), TEST_LOCATION );
- Property::Value* value = map.Find( "foo" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
-
- map.Insert( std::string("foo2"), "testing" );
- DALI_TEST_EQUALS( 2u, map.Count(), TEST_LOCATION );
- value = map.Find( "foo2" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
-
- map.Insert( 10, "DALi" );
- DALI_TEST_EQUALS( 3u, map.Count(), TEST_LOCATION );
- value = map.Find( 10 );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
-
- map.Insert( 100, 9 );
- DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
- value = map.Find( 100 );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 9 );
+ DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
+ map.Insert("foo", "bar");
+ DALI_TEST_EQUALS(1u, map.Count(), TEST_LOCATION);
+ Property::Value* value = map.Find("foo");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
+
+ map.Insert(std::string("foo2"), "testing");
+ DALI_TEST_EQUALS(2u, map.Count(), TEST_LOCATION);
+ value = map.Find("foo2");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
+
+ map.Insert(10, "DALi");
+ DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
+ value = map.Find(10);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
+
+ map.Insert(100, 9);
+ DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
+ value = map.Find(100);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 9);
END_TEST;
}
-
int UtcDaliPropertyMapAddP(void)
{
Property::Map map;
- DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
- map.Add( "foo", "bar");
- DALI_TEST_EQUALS( 1u, map.Count(), TEST_LOCATION );
- Property::Value* value = map.Find( "foo" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
-
- map.Add( std::string("foo2"), "testing" );
- DALI_TEST_EQUALS( 2u, map.Count(), TEST_LOCATION );
- value = map.Find( "foo2" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
-
- map.Add( 10, "DALi" );
- DALI_TEST_EQUALS( 3u, map.Count(), TEST_LOCATION );
- value = map.Find( 10 );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
-
- map.Add( 100, 9 );
- DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
- value = map.Find( 100 );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 9 );
+ DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
+ map.Add("foo", "bar");
+ DALI_TEST_EQUALS(1u, map.Count(), TEST_LOCATION);
+ Property::Value* value = map.Find("foo");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
+
+ map.Add(std::string("foo2"), "testing");
+ DALI_TEST_EQUALS(2u, map.Count(), TEST_LOCATION);
+ value = map.Find("foo2");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
+
+ map.Add(10, "DALi");
+ DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
+ value = map.Find(10);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
+
+ map.Add(100, 9);
+ DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
+ value = map.Find(100);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 9);
END_TEST;
}
int UtcDaliPropertyMapAddChainP(void)
{
Property::Map map;
- DALI_TEST_EQUALS( 0u, map.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, map.Count(), TEST_LOCATION);
map
- .Add( "foo", "bar")
- .Add( std::string("foo2"), "testing" )
- .Add( 10, "DALi" )
- .Add( 100, 9 );
+ .Add("foo", "bar")
+ .Add(std::string("foo2"), "testing")
+ .Add(10, "DALi")
+ .Add(100, 9);
- DALI_TEST_EQUALS( 4u, map.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(4u, map.Count(), TEST_LOCATION);
- Property::Value* value = map.Find( "foo" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
+ Property::Value* value = map.Find("foo");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
- value = map.Find( "foo2" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
+ value = map.Find("foo2");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
- value = map.Find( 10 );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
+ value = map.Find(10);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
- value = map.Find( 100 );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 9 );
+ value = map.Find(100);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 9);
END_TEST;
}
Property::Map mMap;
};
- TestMap mapTest( Property::Map().Add( "foo", "bar")
- .Add( std::string("foo2"), "testing" )
- .Add( 10, "DALi" )
- .Add( 100, 9 ));
-
+ TestMap mapTest(Property::Map().Add("foo", "bar").Add(std::string("foo2"), "testing").Add(10, "DALi").Add(100, 9));
- Property::Value* value = mapTest.mMap.Find( "foo" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "bar", value->Get<std::string>(), TEST_LOCATION );
+ Property::Value* value = mapTest.mMap.Find("foo");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("bar", value->Get<std::string>(), TEST_LOCATION);
- value = mapTest.mMap.Find( "foo2" );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "testing", value->Get<std::string>(), TEST_LOCATION );
+ value = mapTest.mMap.Find("foo2");
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("testing", value->Get<std::string>(), TEST_LOCATION);
- value = mapTest.mMap.Find( 10 );
- DALI_TEST_CHECK( value );
- DALI_TEST_EQUALS( "DALi", value->Get<std::string>(), TEST_LOCATION );
+ value = mapTest.mMap.Find(10);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_EQUALS("DALi", value->Get<std::string>(), TEST_LOCATION);
- value = mapTest.mMap.Find( 100 );
- DALI_TEST_CHECK( value );
- DALI_TEST_CHECK( value->Get<int>() == 9 );
+ value = mapTest.mMap.Find(100);
+ DALI_TEST_CHECK(value);
+ DALI_TEST_CHECK(value->Get<int>() == 9);
END_TEST;
}
-
int UtcDaliPropertyMapMerge(void)
{
Property::Map map;
- map[ "hello" ] = 1;
- map[ 10 ] = "DALi";
- map[ "world" ] = 2;
+ map["hello"] = 1;
+ map[10] = "DALi";
+ map["world"] = 2;
- DALI_TEST_CHECK( map.Count() == 3 );
+ DALI_TEST_CHECK(map.Count() == 3);
// Create another map with the same keys but different values
Property::Map map2;
- map2[ "hello" ] = 3;
- map2[ "world" ] = 4;
- map[ 10 ] = "3DEngine";
+ map2["hello"] = 3;
+ map2["world"] = 4;
+ map[10] = "3DEngine";
// Merge map2 into map1, count should still be 2, map values should be from map2
- map.Merge( map2 );
- DALI_TEST_CHECK( map.Count() == 3 );
- DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
- DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
- DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
+ map.Merge(map2);
+ DALI_TEST_CHECK(map.Count() == 3);
+ DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+ DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+ DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
// Create another map with different keys
Property::Map map3;
- map3[ "foo" ] = 5;
- map3[ 100 ] = 6;
+ map3["foo"] = 5;
+ map3[100] = 6;
// Merge map3 into map1, count should increase, existing values should match previous and new values should match map3
- map.Merge( map3 );
- DALI_TEST_CHECK( map.Count() == 5 );
- DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
- DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
- DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
- DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
- DALI_TEST_CHECK( map[ 100].Get< int >() == 6 );
+ map.Merge(map3);
+ DALI_TEST_CHECK(map.Count() == 5);
+ DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+ DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+ DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
+ DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_CHECK(map[100].Get<int>() == 6);
// Create an empty map and attempt to merge, should be successful, nothing should change
Property::Map map4;
- DALI_TEST_CHECK( map4.Empty() );
- map.Merge( map4 );
- DALI_TEST_CHECK( map4.Empty() );
- DALI_TEST_CHECK( map.Count() == 5 );
- DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
- DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
- DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
- DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
- DALI_TEST_CHECK( map[ 100 ].Get< int >() == 6 );
+ DALI_TEST_CHECK(map4.Empty());
+ map.Merge(map4);
+ DALI_TEST_CHECK(map4.Empty());
+ DALI_TEST_CHECK(map.Count() == 5);
+ DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+ DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+ DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
+ DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_CHECK(map[100].Get<int>() == 6);
// Merge map into map4, map4 should be the same as map now.
- map4.Merge( map );
- DALI_TEST_CHECK( map4.Count() == 5 );
- DALI_TEST_CHECK( map4[ "hello" ].Get< int >() == 3 );
- DALI_TEST_CHECK( map4[ "world"].Get< int >() == 4 );
- DALI_TEST_CHECK( map4[ "foo"].Get< int >() == 5 );
- DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
- DALI_TEST_CHECK( map4[ 100 ].Get< int >() == 6 );
+ map4.Merge(map);
+ DALI_TEST_CHECK(map4.Count() == 5);
+ DALI_TEST_CHECK(map4["hello"].Get<int>() == 3);
+ DALI_TEST_CHECK(map4["world"].Get<int>() == 4);
+ DALI_TEST_CHECK(map4["foo"].Get<int>() == 5);
+ DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_CHECK(map4[100].Get<int>() == 6);
// Attempt to merge into itself, should be successful, nothing should change
- map.Merge( map );
- DALI_TEST_CHECK( map.Count() == 5 );
- DALI_TEST_CHECK( map[ "hello" ].Get< int >() == 3 );
- DALI_TEST_CHECK( map[ "world"].Get< int >() == 4 );
- DALI_TEST_CHECK( map[ "foo"].Get< int >() == 5 );
- DALI_TEST_EQUALS( "3DEngine", map[ 10 ].Get<std::string>(), TEST_LOCATION );
- DALI_TEST_CHECK( map[ 100 ].Get< int >() == 6 );
+ map.Merge(map);
+ DALI_TEST_CHECK(map.Count() == 5);
+ DALI_TEST_CHECK(map["hello"].Get<int>() == 3);
+ DALI_TEST_CHECK(map["world"].Get<int>() == 4);
+ DALI_TEST_CHECK(map["foo"].Get<int>() == 5);
+ DALI_TEST_EQUALS("3DEngine", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_CHECK(map[100].Get<int>() == 6);
END_TEST;
}
Property::Map map;
map.Insert("duration", 5.0f);
- map.Insert( 10, "DALi" );
+ map.Insert(10, "DALi");
map.Insert("delay", 1.0f);
- map.Insert( 100, 9 );
+ map.Insert(100, 9);
map.Insert("value", 100);
std::ostringstream oss;
tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
// string-value pairs first, then index-value pairs
- DALI_TEST_EQUALS( oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(oss.str().compare("Map(5) = {duration:5, delay:1, value:100, 10:DALi, 100:9}"), 0, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliPropertyMapOstream02(void)
{
Property::Map map, map2;
map2.Insert("duration", 5.0f);
map2.Insert("delay", 1.0f);
- map2.Insert( 10, "DALi" );
+ map2.Insert(10, "DALi");
map.Insert("timePeriod", map2);
- map.Insert( 100, 9 );
+ map.Insert(100, 9);
map.Insert("value", 100);
std::ostringstream oss;
tet_printf("Testing ouput of map: %s\n", oss.str().c_str());
// string-value pairs first, then index-value pairs
- DALI_TEST_EQUALS( oss.str().compare("Map(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(oss.str().compare("Map(3) = {timePeriod:Map(3) = {duration:5, delay:1, 10:DALi}, value:100, 100:9}"), 0, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyKeyConstructorP(void)
{
- Property::Key key1( "aKey" );
- DALI_TEST_EQUALS( key1.type, Property::Key::STRING, TEST_LOCATION );
- DALI_TEST_EQUALS( key1.stringKey, "aKey", TEST_LOCATION );
- DALI_TEST_EQUALS( key1.indexKey, Property::INVALID_INDEX, TEST_LOCATION );
-
- Property::Key key2( Actor::Property::COLOR );
- DALI_TEST_EQUALS( key2.type, Property::Key::INDEX, TEST_LOCATION );
- DALI_TEST_EQUALS( key2.indexKey, (Dali::Property::Index)Actor::Property::COLOR, TEST_LOCATION );
+ Property::Key key1("aKey");
+ DALI_TEST_EQUALS(key1.type, Property::Key::STRING, TEST_LOCATION);
+ DALI_TEST_EQUALS(key1.stringKey, "aKey", TEST_LOCATION);
+ DALI_TEST_EQUALS(key1.indexKey, Property::INVALID_INDEX, TEST_LOCATION);
+
+ Property::Key key2(Actor::Property::COLOR);
+ DALI_TEST_EQUALS(key2.type, Property::Key::INDEX, TEST_LOCATION);
+ DALI_TEST_EQUALS(key2.indexKey, (Dali::Property::Index)Actor::Property::COLOR, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyKeyEqualityOperatorP(void)
{
- Property::Key key1( "aKey" );
- Property::Key key2( 113 );
+ Property::Key key1("aKey");
+ Property::Key key2(113);
- DALI_TEST_CHECK( key1 == "aKey" );
- DALI_TEST_CHECK( ! (key1 == "notTheKey") );
- DALI_TEST_CHECK( ! (key1 == 1) );
+ DALI_TEST_CHECK(key1 == "aKey");
+ DALI_TEST_CHECK(!(key1 == "notTheKey"));
+ DALI_TEST_CHECK(!(key1 == 1));
- DALI_TEST_CHECK( key2 == 113 );
- DALI_TEST_CHECK( ! (key2 == 0) );
- DALI_TEST_CHECK( ! (key2 == "One hundred and thirteen" ) );
+ DALI_TEST_CHECK(key2 == 113);
+ DALI_TEST_CHECK(!(key2 == 0));
+ DALI_TEST_CHECK(!(key2 == "One hundred and thirteen"));
- DALI_TEST_CHECK( ! (key1 == key2) );
- DALI_TEST_CHECK( key1 != key2 );
+ DALI_TEST_CHECK(!(key1 == key2));
+ DALI_TEST_CHECK(key1 != key2);
- Property::Key key1B( "aKey" );
- Property::Key key2B( 113 );
+ Property::Key key1B("aKey");
+ Property::Key key2B(113);
- DALI_TEST_CHECK( key1 == key1B );
- DALI_TEST_CHECK( key2 == key2B );
+ DALI_TEST_CHECK(key1 == key1B);
+ DALI_TEST_CHECK(key2 == key2B);
END_TEST;
}
int UtcDaliPropertyKeyInequalityOperatorP(void)
{
- Property::Key key1( "aKey" );
- Property::Key key2( 113 );
+ Property::Key key1("aKey");
+ Property::Key key2(113);
- DALI_TEST_CHECK( key1 != "notTheKey" );
- DALI_TEST_CHECK( key1 != 1 );
+ DALI_TEST_CHECK(key1 != "notTheKey");
+ DALI_TEST_CHECK(key1 != 1);
- DALI_TEST_CHECK( key2 != 0 );
- DALI_TEST_CHECK( key2 != "One hundred and thirteen" );
+ DALI_TEST_CHECK(key2 != 0);
+ DALI_TEST_CHECK(key2 != "One hundred and thirteen");
- DALI_TEST_CHECK( key1 != key2 );
+ DALI_TEST_CHECK(key1 != key2);
END_TEST;
}
-
int UtcDaliPropertyKeyOutputStream(void)
{
- Property::Key key1( "aKey" );
- Property::Key key2( 113 );
+ Property::Key key1("aKey");
+ Property::Key key2(113);
std::ostringstream oss;
oss << key1;
- DALI_TEST_EQUALS( oss.str(), "aKey", TEST_LOCATION );
+ DALI_TEST_EQUALS(oss.str(), "aKey", TEST_LOCATION);
std::ostringstream oss2;
oss2 << key2;
- DALI_TEST_EQUALS( oss2.str(), "113", TEST_LOCATION );
+ DALI_TEST_EQUALS(oss2.str(), "113", TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyMapInitializerListConstructor(void)
{
auto map = Property::Map{
- {"number mapped to string", 1},
- {10, "string mapped to number"},
- {"string mapped", "to string"},
- {100, 3},
+ {"number mapped to string", 1},
+ {10, "string mapped to number"},
+ {"string mapped", "to string"},
+ {100, 3},
};
- DALI_TEST_CHECK( !map.Empty() ); // Should not be empty
- DALI_TEST_EQUALS( 4, map.Count(), TEST_LOCATION ); // Should have four items
+ DALI_TEST_CHECK(!map.Empty()); // Should not be empty
+ DALI_TEST_EQUALS(4, map.Count(), TEST_LOCATION); // Should have four items
- DALI_TEST_EQUALS( 1, map[ "number mapped to string" ].Get< int >(), TEST_LOCATION );
- DALI_TEST_EQUALS( "string mapped to number", map[ 10 ].Get< std::string >(), TEST_LOCATION );
- DALI_TEST_EQUALS( "to string", map[ "string mapped" ].Get< std::string >(), TEST_LOCATION );
- DALI_TEST_EQUALS( 3, map[ 100 ].Get< int >(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, map["number mapped to string"].Get<int>(), TEST_LOCATION);
+ DALI_TEST_EQUALS("string mapped to number", map[10].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS("to string", map["string mapped"].Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(3, map[100].Get<int>(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyMapNestedInitializerListConstructor(void)
{
- auto map = Property::Map
- {
+ auto map = Property::Map{
{1, 1},
{2, {{2, 2}}},
- {3, {{3, {{3, 3}}}}}
- };
+ {3, {{3, {{3, 3}}}}}};
- DALI_TEST_CHECK( !map.Empty() );
- DALI_TEST_EQUALS( 3, map.Count(), TEST_LOCATION );
+ DALI_TEST_CHECK(!map.Empty());
+ DALI_TEST_EQUALS(3, map.Count(), TEST_LOCATION);
// Check first item
{
- DALI_TEST_EQUALS( 1, map[ 1 ].Get< int >(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, map[1].Get<int>(), TEST_LOCATION);
}
// Check second item
{
- auto& value1 = map[ 2 ];
- DALI_TEST_EQUALS( Property::MAP, value1.GetType(), TEST_LOCATION );
+ auto& value1 = map[2];
+ DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
auto& map2 = *(value1.GetMap());
- DALI_TEST_EQUALS( 1, map2.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
// check the value
- DALI_TEST_EQUALS( 2, map2[ 2 ].Get< int >(), TEST_LOCATION );
+ DALI_TEST_EQUALS(2, map2[2].Get<int>(), TEST_LOCATION);
}
// Check the third item
{
- auto& value1 = map[ 3 ];
- DALI_TEST_EQUALS( Property::MAP, value1.GetType(), TEST_LOCATION );
+ auto& value1 = map[3];
+ DALI_TEST_EQUALS(Property::MAP, value1.GetType(), TEST_LOCATION);
auto& map2 = *(value1.GetMap());
- DALI_TEST_EQUALS( 1, map2.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, map2.Count(), TEST_LOCATION);
- auto& value2 = map2[ 3 ];
- DALI_TEST_EQUALS( Property::MAP, value2.GetType(), TEST_LOCATION );
+ auto& value2 = map2[3];
+ DALI_TEST_EQUALS(Property::MAP, value2.GetType(), TEST_LOCATION);
auto& map3 = *(value2.GetMap());
- DALI_TEST_EQUALS( 1, map3.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, map3.Count(), TEST_LOCATION);
// check the value
- DALI_TEST_EQUALS( 3, map3[ 3 ].Get< int >(), TEST_LOCATION );
+ DALI_TEST_EQUALS(3, map3[3].Get<int>(), TEST_LOCATION);
}
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-namespace {
-
+namespace
+{
static bool gCallBackCalled;
static void TestCallback(PropertyNotification& source)
gCallBackCalled = true;
}
-const int RENDER_FRAME_INTERVAL(16); ///< Duration of each frame in ms. (at approx 60FPS)
-const int DEFAULT_WAIT_PERIOD(100); ///< Default waiting period for check.
-
+const int RENDER_FRAME_INTERVAL(16); ///< Duration of each frame in ms. (at approx 60FPS)
+const int DEFAULT_WAIT_PERIOD(100); ///< Default waiting period for check.
class TestClass : public ConnectionTracker
{
public:
-
- TestClass(Integration::Scene scene )
- : mScene( scene )
+ TestClass(Integration::Scene scene)
+ : mScene(scene)
{
}
void Initialize()
{
mActor = Actor::New();
- mScene.Add( mActor );
- mNotification = mActor.AddPropertyNotification( Actor::Property::POSITION_X, GreaterThanCondition(100.0f) );
- mNotification.NotifySignal().Connect( this, &TestClass::OnPropertyNotify );
+ mScene.Add(mActor);
+ mNotification = mActor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
+ mNotification.NotifySignal().Connect(this, &TestClass::OnPropertyNotify);
}
void RemovePropertyNotification()
{
- mActor.RemovePropertyNotification( mNotification );
+ mActor.RemovePropertyNotification(mNotification);
}
void RemovePropertyNotifications()
void Terminate()
{
- mScene.Remove( mActor );
+ mScene.Remove(mActor);
mActor.Reset();
mNotification.Reset();
}
- void OnPropertyNotify( PropertyNotification& source )
+ void OnPropertyNotify(PropertyNotification& source)
{
tet_infoline(" OnPropertyNotify");
gCallBackCalled = true;
}
- Actor mActor;
+ Actor mActor;
PropertyNotification mNotification;
- Integration::Scene mScene;
+ Integration::Scene mScene;
};
-
/*
* Simulate time passed by.
*
{
int time = 0;
- for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
+ for(int i = 0; i <= (duration / RENDER_FRAME_INTERVAL); i++)
{
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
} // unnamed namespace
-
// Positive test case for a method
int UtcDaliPropertyNotificationDownCast(void)
{
TestApplication application;
tet_infoline(" UtcDaliPropertyNotificationDownCast");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
- BaseHandle handle = notification;
+ BaseHandle handle = notification;
PropertyNotification notificationHandle;
DALI_TEST_CHECK(notification);
DALI_TEST_CHECK(handle);
DALI_TEST_CHECK(!notificationHandle);
- notificationHandle = PropertyNotification::DownCast( handle );
+ notificationHandle = PropertyNotification::DownCast(handle);
DALI_TEST_CHECK(notificationHandle);
END_TEST;
}
-
// Negative test case for a method
int UtcDaliPropertyNotificationDownCastNegative(void)
{
Actor actor = Actor::New();
actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
- BaseHandle handle = somethingElse;
+ BaseHandle handle = somethingElse;
PropertyNotification notificationHandle;
- notificationHandle = PropertyNotification::DownCast( handle );
+ notificationHandle = PropertyNotification::DownCast(handle);
DALI_TEST_CHECK(!notificationHandle);
END_TEST;
}
Actor actor = Actor::New();
PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
- DALI_TEST_CHECK( notification );
- DALI_TEST_EQUALS( 2, notification.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(notification);
+ DALI_TEST_EQUALS(2, notification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- PropertyNotification movedNotification = std::move( notification );
- DALI_TEST_CHECK( movedNotification );
+ PropertyNotification movedNotification = std::move(notification);
+ DALI_TEST_CHECK(movedNotification);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 2, movedNotification.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !notification );
+ DALI_TEST_EQUALS(2, movedNotification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!notification);
PropertyCondition condition = movedNotification.GetCondition();
- DALI_TEST_CHECK( condition );
- DALI_TEST_EQUALS( 2, condition.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, condition.GetArgumentCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(condition);
+ DALI_TEST_EQUALS(2, condition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, condition.GetArgumentCount(), TEST_LOCATION);
- PropertyCondition movedCondition = std::move( condition );
- DALI_TEST_CHECK( movedCondition );
+ PropertyCondition movedCondition = std::move(condition);
+ DALI_TEST_CHECK(movedCondition);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 2, movedCondition.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, movedCondition.GetArgumentCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !condition );
+ DALI_TEST_EQUALS(2, movedCondition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, movedCondition.GetArgumentCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!condition);
END_TEST;
}
Actor actor = Actor::New();
PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
- DALI_TEST_CHECK( notification );
- DALI_TEST_EQUALS( 2, notification.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(notification);
+ DALI_TEST_EQUALS(2, notification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
PropertyNotification movedNotification;
- movedNotification = std::move( notification );
- DALI_TEST_CHECK( movedNotification );
+ movedNotification = std::move(notification);
+ DALI_TEST_CHECK(movedNotification);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 2, movedNotification.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !notification );
+ DALI_TEST_EQUALS(2, movedNotification.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!notification);
PropertyCondition condition = movedNotification.GetCondition();
- DALI_TEST_CHECK( condition );
- DALI_TEST_EQUALS( 2, condition.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, condition.GetArgumentCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(condition);
+ DALI_TEST_EQUALS(2, condition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, condition.GetArgumentCount(), TEST_LOCATION);
PropertyCondition movedCondition;
- movedCondition = std::move( condition );
- DALI_TEST_CHECK( movedCondition );
+ movedCondition = std::move(condition);
+ DALI_TEST_CHECK(movedCondition);
// Check that object is moved (not copied, so ref count keeps the same)
- DALI_TEST_EQUALS( 2, movedCondition.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1, movedCondition.GetArgumentCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !condition );
+ DALI_TEST_EQUALS(2, movedCondition.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1, movedCondition.GetArgumentCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!condition);
END_TEST;
}
Actor actor = Actor::New();
- PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
- PropertyNotification notification2 = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition( 1.0f, 1.0f ));
- DALI_TEST_CHECK( notification );
- DALI_TEST_CHECK( notification2 );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
+ PropertyNotification notification2 = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
+ DALI_TEST_CHECK(notification);
+ DALI_TEST_CHECK(notification2);
END_TEST;
}
gCallBackCalled = false;
tet_infoline(" UtcDaliAddPropertyNotificationCallback - Forcing notification condition true, should receive a notification");
- object->mActor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
gCallBackCalled = false;
tet_infoline(" UtcDaliAddPropertyNotificationCallback - Forcing notification condition false, should not receive a notification");
- object->mActor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ object->mActor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
gCallBackCalled = false;
tet_infoline(" UtcDaliAddPropertyNotificationCallback - Deleting notification and it's owning object, should not receive a notification");
- object->mActor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
object->Terminate();
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
tet_infoline(" UtcDaliAddPropertyNotificationCallback - Removing notification and it's owning object, should not receive a notification");
object->Initialize();
object->RemovePropertyNotification();
- object->mActor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
tet_infoline(" UtcDaliAddPropertyNotificationCallback - Removing all notifications and it's owning object, should not receive a notification");
object->Initialize();
object->RemovePropertyNotifications();
- object->mActor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ object->mActor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
- DALI_TEST_CHECK( !gCallBackCalled );
-
+ DALI_TEST_CHECK(!gCallBackCalled);
delete object;
END_TEST;
// Currently, Type registry properties cannot be animated
try
{
- actor.AddPropertyNotification( PROPERTY_REGISTRATION_START_INDEX, GreaterThanCondition( 100.0f ) );
+ actor.AddPropertyNotification(PROPERTY_REGISTRATION_START_INDEX, GreaterThanCondition(100.0f));
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property notification added to event side only property", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property notification added to event side only property", TEST_LOCATION);
}
END_TEST;
}
// Currently, Type registry properties cannot be animated
try
{
- actor.AddPropertyNotification( PROPERTY_REGISTRATION_MAX_INDEX - 1, GreaterThanCondition( 100.0f ) );
+ actor.AddPropertyNotification(PROPERTY_REGISTRATION_MAX_INDEX - 1, GreaterThanCondition(100.0f));
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property notification added to event side only property", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property notification added to event side only property", TEST_LOCATION);
}
END_TEST;
}
Actor actor = Actor::New();
- PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition( 1.0f, 1.0f ));
- DALI_TEST_CHECK( notification );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
+ DALI_TEST_CHECK(notification);
END_TEST;
}
Actor actor = Actor::New();
- PropertyCondition condition = GreaterThanCondition(100.0f);
+ PropertyCondition condition = GreaterThanCondition(100.0f);
PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, condition);
- DALI_TEST_CHECK( condition == notification.GetCondition() );
+ DALI_TEST_CHECK(condition == notification.GetCondition());
END_TEST;
}
class PropertyNotificationConstWrapper
{
public:
-
PropertyNotificationConstWrapper(PropertyNotification propertyNotification)
- :mPropertyNotification(propertyNotification)
+ : mPropertyNotification(propertyNotification)
{
-
}
/**
Actor actor = Actor::New();
- PropertyCondition condition = GreaterThanCondition(100.0f);
- PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, condition);
+ PropertyCondition condition = GreaterThanCondition(100.0f);
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, condition);
PropertyNotificationConstWrapper notificationConst(notification);
- const PropertyCondition& conditionReference1 = notificationConst.GetCondition();
- const PropertyCondition& conditionReference2 = notificationConst.GetCondition();
+ const PropertyCondition& conditionReference1 = notificationConst.GetCondition();
+ const PropertyCondition& conditionReference2 = notificationConst.GetCondition();
- DALI_TEST_CHECK( (&conditionReference1) == (&conditionReference2) );
- DALI_TEST_CHECK( conditionReference1 == condition );
+ DALI_TEST_CHECK((&conditionReference1) == (&conditionReference2));
+ DALI_TEST_CHECK(conditionReference1 == condition);
END_TEST;
}
TestApplication application;
tet_infoline(" UtcDaliPropertyNotificationGetTarget");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
Actor actor2 = Actor::New();
PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X,
GreaterThanCondition(100.0f));
- Actor targetActor = Actor::DownCast( notification.GetTarget() );
+ Actor targetActor = Actor::DownCast(notification.GetTarget());
- DALI_TEST_CHECK( targetActor == actor );
+ DALI_TEST_CHECK(targetActor == actor);
END_TEST;
}
Actor actor = Actor::New();
- PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X,
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X,
GreaterThanCondition(100.0f));
- Property::Index targetProperty = notification.GetTargetProperty();
+ Property::Index targetProperty = notification.GetTargetProperty();
- DALI_TEST_EQUALS( targetProperty, (Property::Index)Actor::Property::POSITION_X, TEST_LOCATION );
+ DALI_TEST_EQUALS(targetProperty, (Property::Index)Actor::Property::POSITION_X, TEST_LOCATION);
END_TEST;
}
notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
PropertyNotification::NotifyMode notifyMode = notification.GetNotifyMode();
- DALI_TEST_EQUALS( notifyMode, PropertyNotification::NOTIFY_ON_CHANGED, TEST_LOCATION );
+ DALI_TEST_EQUALS(notifyMode, PropertyNotification::NOTIFY_ON_CHANGED, TEST_LOCATION);
END_TEST;
}
GreaterThanCondition(100.0f));
notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
gCallBackCalled = false;
- notification.NotifySignal().Connect( &TestCallback );
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
bool notifyResult = notification.GetNotifyResult();
- DALI_TEST_EQUALS( notifyResult, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(notifyResult, false, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION_X, GreaterThanCondition(100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move right to satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move left to un-satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
// Move right to satisfy condition again.
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION_X, LessThanCondition(100.0f ) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, LessThanCondition(100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move left to satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move right to un-satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
// Move left to satisfy condition again.
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION_X, InsideCondition(100.0f, 200.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, InsideCondition(100.0f, 200.0f));
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move inside to satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move outside (right) to un-satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(300.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(300.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
// Move inside to satisfy condition again.
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION_X, OutsideCondition(100.0f, 200.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION_X, OutsideCondition(100.0f, 200.0f));
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move outside (left) to satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move inside to un-satisfy condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(150.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
// Move outside (right) to satisfy condition again.
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(300.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(300.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, 0, GreaterThanCondition(100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 1, GreaterThanCondition(100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 2, GreaterThanCondition(100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::COLOR, 3, GreaterThanCondition(0.5f) );
- notification.NotifySignal().Connect( &TestCallback );
-
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, GreaterThanCondition(100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, GreaterThanCondition(100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, GreaterThanCondition(100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, GreaterThanCondition(0.5f));
+ notification.NotifySignal().Connect(&TestCallback);
+
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move right to satisfy XAxis condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move down to satisfy YAxis condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 200.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move forward to satisfy ZAxis
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Change alpha Colour to satisfy w/alpha component condition
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, 0, LessThanCondition(-100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 1, LessThanCondition(-100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 2, LessThanCondition(-100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::COLOR, 3, LessThanCondition(0.5f) );
- notification.NotifySignal().Connect( &TestCallback );
-
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, LessThanCondition(-100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, LessThanCondition(-100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, LessThanCondition(-100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, LessThanCondition(0.5f));
+ notification.NotifySignal().Connect(&TestCallback);
+
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move left to satisfy XAxis condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(-200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(-200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move up to satisfy YAxis condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(-200.0f, -200.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(-200.0f, -200.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move back to satisfy ZAxis
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(-200.0f, -200.0f, -200.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(-200.0f, -200.0f, -200.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Change alpha Colour to satisfy w/alpha component condition
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, 0, InsideCondition(-100.0f, 100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 1, InsideCondition(-100.0f, 100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 2, InsideCondition(-100.0f, 100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::COLOR, 3, InsideCondition(0.25f, 0.75f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, InsideCondition(-100.0f, 100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, InsideCondition(-100.0f, 100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, InsideCondition(-100.0f, 100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, InsideCondition(0.25f, 0.75f));
+ notification.NotifySignal().Connect(&TestCallback);
// set outside all conditions
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move x to inside condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 200.0f, 200.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 200.0f, 200.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move y to inside condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 200.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 200.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move z to inside condition
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// change alpha to inside condition
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 0.5f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.5f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, 0, OutsideCondition(-100.0f, 100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 1, OutsideCondition(-100.0f, 100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::POSITION, 2, OutsideCondition(-100.0f, 100.0f) );
- notification.NotifySignal().Connect( &TestCallback );
- notification = actor.AddPropertyNotification( Actor::Property::COLOR, 3, OutsideCondition(0.25f, 0.75f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, OutsideCondition(-100.0f, 100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 1, OutsideCondition(-100.0f, 100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::POSITION, 2, OutsideCondition(-100.0f, 100.0f));
+ notification.NotifySignal().Connect(&TestCallback);
+ notification = actor.AddPropertyNotification(Actor::Property::COLOR, 3, OutsideCondition(0.25f, 0.75f));
+ notification.NotifySignal().Connect(&TestCallback);
// set inside all conditions
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 0.5f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 0.5f));
Wait(application, DEFAULT_WAIT_PERIOD);
// Move x to outside condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move y to outside condition
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 200.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// Move z to outside condition
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(200.0f, 200.0f, 200.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
// change alpha to outside condition
gCallBackCalled = false;
Wait(application, DEFAULT_WAIT_PERIOD);
- actor.SetProperty( Actor::Property::COLOR,Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(0.0f, 0.0f, 0.0f, 1.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
END_TEST;
}
int UtcDaliPropertyNotificationSetSizeResultP(void)
{
TestApplication application;
- bool notifyResult;
+ bool notifyResult;
tet_infoline(" UtcDaliPropertyNotificationSetSizeResultP");
Actor actor = Actor::New();
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::SIZE, StepCondition( 1.0f, 1.0f ) );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::SIZE, StepCondition(1.0f, 1.0f));
notification.SetNotifyMode(PropertyNotification::NOTIFY_ON_CHANGED);
gCallBackCalled = false;
- notification.NotifySignal().Connect( &TestCallback );
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
notifyResult = notification.GetNotifyResult();
- DALI_TEST_EQUALS( notifyResult, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(notifyResult, true, TEST_LOCATION);
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::SIZE, Vector2( 200.0f, 200.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(200.0f, 200.0f));
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
notifyResult = notification.GetNotifyResult();
- DALI_TEST_EQUALS( notifyResult, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(notifyResult, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
tet_infoline(" UtcDaliPropertyConditionGetArguments");
- PropertyCondition condition = GreaterThanCondition( 50.0f );
+ PropertyCondition condition = GreaterThanCondition(50.0f);
- DALI_TEST_EQUALS( condition.GetArgumentCount(), 1u, TEST_LOCATION );
- float value = condition.GetArgument( 0 );
- DALI_TEST_EQUALS( value, 50.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(condition.GetArgumentCount(), 1u, TEST_LOCATION);
+ float value = condition.GetArgument(0);
+ DALI_TEST_EQUALS(value, 50.0f, TEST_LOCATION);
- condition = InsideCondition( 125.0f, 250.0f );
+ condition = InsideCondition(125.0f, 250.0f);
- DALI_TEST_EQUALS( condition.GetArgumentCount(), 2u, TEST_LOCATION );
- float value1 = condition.GetArgument( 0 );
- float value2 = condition.GetArgument( 1 );
- DALI_TEST_EQUALS( value1, 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( value2, 250.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(condition.GetArgumentCount(), 2u, TEST_LOCATION);
+ float value1 = condition.GetArgument(0);
+ float value2 = condition.GetArgument(1);
+ DALI_TEST_EQUALS(value1, 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(value2, 250.0f, TEST_LOCATION);
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- const float step = 10.0f;
- float initValue = 5.0f;
+ const float step = 10.0f;
+ float initValue = 5.0f;
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::COLOR, StepCondition(step * 2, 0.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::COLOR, StepCondition(step * 2, 0.0f));
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( Actor::Property::COLOR, Vector4(initValue, 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(initValue, 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// test both directions
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to positive
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::COLOR, Vector4(initValue + (i++ * step), 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(initValue + (i++ * step), 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( Actor::Property::COLOR, Vector4(initValue + (i++ * step), 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(initValue + (i++ * step), 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
initValue = -5.0f;
- actor.SetProperty( Actor::Property::COLOR, Vector4(initValue, 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(initValue, 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to negative
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::COLOR, Vector4(initValue -(i++ * step), 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(initValue - (i++ * step), 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( Actor::Property::COLOR, Vector4(initValue -(i++ * step), 0.0f, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(initValue - (i++ * step), 0.0f, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- const float step = 10.0f;
- float initValue = 5.0f;
+ const float step = 10.0f;
+ float initValue = 5.0f;
// float
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, 0, StepCondition(step * 2, 0.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, StepCondition(step * 2, 0.0f));
+ notification.NotifySignal().Connect(&TestCallback);
// set initial position
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// test both directions
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to positive
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
initValue = -5.0f;
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to negative
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue -(i++ * step), 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue -(i++ * step), 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- const float step = 10.0f;
- float initValue = 5.0f;
+ const float step = 10.0f;
+ float initValue = 5.0f;
- Property::Index propertyIndex = actor.RegisterProperty( "testProperty", Vector2::ZERO );
+ Property::Index propertyIndex = actor.RegisterProperty("testProperty", Vector2::ZERO);
- PropertyNotification notification = actor.AddPropertyNotification( propertyIndex, StepCondition(step * 2, 0.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(propertyIndex, StepCondition(step * 2, 0.0f));
+ notification.NotifySignal().Connect(&TestCallback);
- actor.SetProperty( propertyIndex, Vector2(initValue, 0.0f));
+ actor.SetProperty(propertyIndex, Vector2(initValue, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// test both directions
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to positive
gCallBackCalled = false;
- actor.SetProperty( propertyIndex, Vector2(initValue + (i++ * step), 0.0f));
+ actor.SetProperty(propertyIndex, Vector2(initValue + (i++ * step), 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( propertyIndex, Vector2(initValue + (i++ * step), 0.0f));
+ actor.SetProperty(propertyIndex, Vector2(initValue + (i++ * step), 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
initValue = -5.0f;
- actor.SetProperty( propertyIndex, Vector2(initValue, 0.0f));
+ actor.SetProperty(propertyIndex, Vector2(initValue, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to negative
gCallBackCalled = false;
- actor.SetProperty( propertyIndex, Vector2(initValue -(i++ * step), 0.0f));
+ actor.SetProperty(propertyIndex, Vector2(initValue - (i++ * step), 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( propertyIndex, Vector2(initValue -(i++ * step), 0.0f));
+ actor.SetProperty(propertyIndex, Vector2(initValue - (i++ * step), 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
END_TEST;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
- const float step = 10.0f;
- float initValue = 5.0f;
+ const float step = 10.0f;
+ float initValue = 5.0f;
// float
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, StepCondition(step * 2, 0.0f) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, StepCondition(step * 2, 0.0f));
+ notification.NotifySignal().Connect(&TestCallback);
// set initial position
- actor.SetProperty( Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
// test both directions
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to positive position
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3( initValue + (i++ * step), 0.0f, 0.0f) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( Actor::Property::POSITION, Vector3( initValue + (i++ * step), 0.0f, 0.0f) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue + (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
initValue = -5.0f;
- actor.SetProperty( Actor::Property::POSITION, Vector3( initValue, 0.0f, 0.0f) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- for( int i = 1 ; i < 10 ; )
+ for(int i = 1; i < 10;)
{
// Move x to negative position
gCallBackCalled = false;
- actor.SetProperty( Actor::Property::POSITION, Vector3( initValue -(i++ * step), 0.0f, 0.0f) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( !gCallBackCalled );
+ DALI_TEST_CHECK(!gCallBackCalled);
- actor.SetProperty( Actor::Property::POSITION, Vector3( initValue -(i++ * step), 0.0f, 0.0f) );
+ actor.SetProperty(Actor::Property::POSITION, Vector3(initValue - (i++ * step), 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
END_TEST;
}
const float averageStep = 100.0f;
- for( int i = 1 ; i < 10 ; i++ )
+ for(int i = 1; i < 10; i++)
{
values.PushBack(i * averageStep + (i % 2 == 0 ? -(averageStep * 0.2f) : (averageStep * 0.2f)));
}
// float
- PropertyNotification notification = actor.AddPropertyNotification( Actor::Property::POSITION, 0, VariableStepCondition(values) );
- notification.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification = actor.AddPropertyNotification(Actor::Property::POSITION, 0, VariableStepCondition(values));
+ notification.NotifySignal().Connect(&TestCallback);
// set initial position lower than first position in list
- actor.SetProperty( Actor::Property::POSITION, Vector3(values[0] - averageStep, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(values[0] - averageStep, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- for( unsigned int i = 0 ; i < values.Count() - 1 ; ++i )
+ for(unsigned int i = 0; i < values.Count() - 1; ++i)
{
gCallBackCalled = false;
// set position half way between the current values
float position = values[i] + (0.5f * (values[i + 1] - values[i]));
- actor.SetProperty( Actor::Property::POSITION, Vector3(position, 0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(position, 0.0f, 0.0f));
Wait(application, DEFAULT_WAIT_PERIOD);
- DALI_TEST_CHECK( gCallBackCalled );
+ DALI_TEST_CHECK(gCallBackCalled);
}
END_TEST;
}
static bool gCallBack2Called = false;
-void TestCallback2(PropertyNotification& source)
+void TestCallback2(PropertyNotification& source)
{
gCallBack2Called = true;
}
Actor actor = Actor::New();
application.GetScene().Add(actor);
// this should complete in first frame
- PropertyNotification notification1 = actor.AddPropertyNotification( Actor::Property::POSITION_X, GreaterThanCondition(90.0f) );
- notification1.NotifySignal().Connect( &TestCallback );
+ PropertyNotification notification1 = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(90.0f));
+ notification1.NotifySignal().Connect(&TestCallback);
// this should complete in second frame
- PropertyNotification notification2 = actor.AddPropertyNotification( Actor::Property::POSITION_X, GreaterThanCondition(150.0f) );
- notification2.NotifySignal().Connect( &TestCallback2 );
- Animation animation = Animation::New( 0.032f ); // finishes in 32 ms
- animation.AnimateTo( Property(actor, Actor::Property::POSITION ), Vector3( 200.0f, 0.0f, 0.0f ), AlphaFunction::LINEAR );
+ PropertyNotification notification2 = actor.AddPropertyNotification(Actor::Property::POSITION_X, GreaterThanCondition(150.0f));
+ notification2.NotifySignal().Connect(&TestCallback2);
+ Animation animation = Animation::New(0.032f); // finishes in 32 ms
+ animation.AnimateTo(Property(actor, Actor::Property::POSITION), Vector3(200.0f, 0.0f, 0.0f), AlphaFunction::LINEAR);
animation.Play();
// flush the queue
// first frame
application.Render(RENDER_FRAME_INTERVAL);
// no notifications yet
- DALI_TEST_EQUALS( gCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gCallBack2Called, false, TEST_LOCATION );
- gCallBackCalled = false;
+ DALI_TEST_EQUALS(gCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gCallBack2Called, false, TEST_LOCATION);
+ gCallBackCalled = false;
gCallBack2Called = false;
// dont serve the notifications but run another update & render
// this simulates situation where there is a notification in event side but it's not been picked up by event thread
// second frame
application.Render(RENDER_FRAME_INTERVAL);
- DALI_TEST_EQUALS( gCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gCallBack2Called, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gCallBack2Called, false, TEST_LOCATION);
// serve the notifications
application.SendNotification();
- DALI_TEST_EQUALS( gCallBackCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( gCallBack2Called, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(gCallBackCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(gCallBack2Called, true, TEST_LOCATION);
- gCallBackCalled = false;
+ gCallBackCalled = false;
gCallBack2Called = false;
application.Render(RENDER_FRAME_INTERVAL);
application.SendNotification();
- DALI_TEST_EQUALS( gCallBackCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( gCallBack2Called, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(gCallBackCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(gCallBack2Called, false, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyConditionGetArgumentNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::PropertyCondition instance;
instance.Reset();
try
int UtcDaliPropertyConditionGetArgumentCountNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::PropertyCondition instance;
instance.Reset();
try
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <iomanip>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iomanip>
+#include <iostream>
using namespace Dali;
int UtcDaliPropertyTypesGetNameP(void)
{
- DALI_TEST_EQUALS( "NONE", Dali::PropertyTypes::GetName(Property::NONE ), TEST_LOCATION );
- DALI_TEST_EQUALS( "BOOLEAN", Dali::PropertyTypes::GetName(Property::BOOLEAN ), TEST_LOCATION );
- DALI_TEST_EQUALS( "FLOAT", Dali::PropertyTypes::GetName(Property::FLOAT ), TEST_LOCATION );
- DALI_TEST_EQUALS( "INTEGER", Dali::PropertyTypes::GetName(Property::INTEGER ), TEST_LOCATION );
- DALI_TEST_EQUALS( "VECTOR2", Dali::PropertyTypes::GetName(Property::VECTOR2 ), TEST_LOCATION );
- DALI_TEST_EQUALS( "VECTOR3", Dali::PropertyTypes::GetName(Property::VECTOR3 ), TEST_LOCATION );
- DALI_TEST_EQUALS( "VECTOR4", Dali::PropertyTypes::GetName(Property::VECTOR4 ), TEST_LOCATION );
- DALI_TEST_EQUALS( "MATRIX3", Dali::PropertyTypes::GetName(Property::MATRIX3 ), TEST_LOCATION );
- DALI_TEST_EQUALS( "MATRIX", Dali::PropertyTypes::GetName(Property::MATRIX ), TEST_LOCATION );
- DALI_TEST_EQUALS( "RECTANGLE", Dali::PropertyTypes::GetName(Property::RECTANGLE ), TEST_LOCATION );
- DALI_TEST_EQUALS( "ROTATION", Dali::PropertyTypes::GetName(Property::ROTATION ), TEST_LOCATION );
- DALI_TEST_EQUALS( "STRING", Dali::PropertyTypes::GetName(Property::STRING ), TEST_LOCATION );
- DALI_TEST_EQUALS( "ARRAY", Dali::PropertyTypes::GetName(Property::ARRAY ), TEST_LOCATION );
- DALI_TEST_EQUALS( "MAP", Dali::PropertyTypes::GetName(Property::MAP ), TEST_LOCATION );
+ DALI_TEST_EQUALS("NONE", Dali::PropertyTypes::GetName(Property::NONE), TEST_LOCATION);
+ DALI_TEST_EQUALS("BOOLEAN", Dali::PropertyTypes::GetName(Property::BOOLEAN), TEST_LOCATION);
+ DALI_TEST_EQUALS("FLOAT", Dali::PropertyTypes::GetName(Property::FLOAT), TEST_LOCATION);
+ DALI_TEST_EQUALS("INTEGER", Dali::PropertyTypes::GetName(Property::INTEGER), TEST_LOCATION);
+ DALI_TEST_EQUALS("VECTOR2", Dali::PropertyTypes::GetName(Property::VECTOR2), TEST_LOCATION);
+ DALI_TEST_EQUALS("VECTOR3", Dali::PropertyTypes::GetName(Property::VECTOR3), TEST_LOCATION);
+ DALI_TEST_EQUALS("VECTOR4", Dali::PropertyTypes::GetName(Property::VECTOR4), TEST_LOCATION);
+ DALI_TEST_EQUALS("MATRIX3", Dali::PropertyTypes::GetName(Property::MATRIX3), TEST_LOCATION);
+ DALI_TEST_EQUALS("MATRIX", Dali::PropertyTypes::GetName(Property::MATRIX), TEST_LOCATION);
+ DALI_TEST_EQUALS("RECTANGLE", Dali::PropertyTypes::GetName(Property::RECTANGLE), TEST_LOCATION);
+ DALI_TEST_EQUALS("ROTATION", Dali::PropertyTypes::GetName(Property::ROTATION), TEST_LOCATION);
+ DALI_TEST_EQUALS("STRING", Dali::PropertyTypes::GetName(Property::STRING), TEST_LOCATION);
+ DALI_TEST_EQUALS("ARRAY", Dali::PropertyTypes::GetName(Property::ARRAY), TEST_LOCATION);
+ DALI_TEST_EQUALS("MAP", Dali::PropertyTypes::GetName(Property::MAP), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyTypesGet02P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<bool>() == Property::BOOLEAN );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<bool>() == Property::BOOLEAN);
END_TEST;
}
int UtcDaliPropertyTypesGet03P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<float>() == Property::FLOAT );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<float>() == Property::FLOAT);
END_TEST;
}
int UtcDaliPropertyTypesGet04P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<int>() == Property::INTEGER );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<int>() == Property::INTEGER);
END_TEST;
}
int UtcDaliPropertyTypesGet06P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Vector2>() == Property::VECTOR2 );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Vector2>() == Property::VECTOR2);
END_TEST;
}
int UtcDaliPropertyTypesGet07P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Vector3>() == Property::VECTOR3 );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Vector3>() == Property::VECTOR3);
END_TEST;
}
int UtcDaliPropertyTypesGet08P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Vector4>() == Property::VECTOR4 );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Vector4>() == Property::VECTOR4);
END_TEST;
}
int UtcDaliPropertyTypesGet09P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Matrix3>() == Property::MATRIX3 );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Matrix3>() == Property::MATRIX3);
END_TEST;
}
int UtcDaliPropertyTypesGet10(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Matrix>() == Property::MATRIX );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Matrix>() == Property::MATRIX);
END_TEST;
}
int UtcDaliPropertyTypesGet11P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::AngleAxis>() == Property::ROTATION );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::AngleAxis>() == Property::ROTATION);
END_TEST;
}
int UtcDaliPropertyTypesGet12P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Quaternion>() == Property::ROTATION );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Quaternion>() == Property::ROTATION);
END_TEST;
}
int UtcDaliPropertyTypesGet13P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<std::string>() == Property::STRING );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<std::string>() == Property::STRING);
END_TEST;
}
int UtcDaliPropertyTypesGet14P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Rect<int> >() == Property::RECTANGLE );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Rect<int> >() == Property::RECTANGLE);
END_TEST;
}
int UtcDaliPropertyTypesGet15P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Property::Map>() == Property::MAP );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Property::Map>() == Property::MAP);
END_TEST;
}
int UtcDaliPropertyTypesGet16P(void)
{
- DALI_TEST_CHECK( Dali::PropertyTypes::Get<Dali::Property::Array>() == Property::ARRAY );
+ DALI_TEST_CHECK(Dali::PropertyTypes::Get<Dali::Property::Array>() == Property::ARRAY);
END_TEST;
}
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <iomanip>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iomanip>
+#include <iostream>
using namespace Dali;
namespace
{
-
-template <typename T>
+template<typename T>
struct CheckCopyCtorP
{
CheckCopyCtorP(Property::Value value)
{
- Property::Value copy( value );
- DALI_TEST_CHECK( value.Get<T>() == copy.Get<T>() );
+ Property::Value copy(value);
+ DALI_TEST_CHECK(value.Get<T>() == copy.Get<T>());
}
};
test_return_value = TET_PASS;
}
-
int UtcDaliPropertyValueConstructorsNoneP(void)
{
Property::Value value;
- DALI_TEST_CHECK( value.GetType() == Property::NONE );
+ DALI_TEST_CHECK(value.GetType() == Property::NONE);
END_TEST;
}
int UtcDaliPropertyValueConstructorsNoneTypeP(void)
{
- Property::Value value( Property::NONE );
+ Property::Value value(Property::NONE);
- DALI_TEST_CHECK( value.GetType() == Property::NONE );
+ DALI_TEST_CHECK(value.GetType() == Property::NONE);
END_TEST;
}
{
Property::Value value(true);
- DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
- DALI_TEST_CHECK( value.Get<bool>() == true );
+ DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
+ DALI_TEST_CHECK(value.Get<bool>() == true);
END_TEST;
}
{
Property::Value value(Property::BOOLEAN);
- DALI_TEST_CHECK( value.GetType() == Property::BOOLEAN );
- DALI_TEST_CHECK( value.Get<bool>() == false );
+ DALI_TEST_CHECK(value.GetType() == Property::BOOLEAN);
+ DALI_TEST_CHECK(value.Get<bool>() == false);
END_TEST;
}
{
Property::Value value(2.f);
- DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
- DALI_TEST_CHECK( value.Get<float>() == 2.f );
+ DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
+ DALI_TEST_CHECK(value.Get<float>() == 2.f);
END_TEST;
}
{
Property::Value value(Property::FLOAT);
- DALI_TEST_CHECK( value.GetType() == Property::FLOAT );
- DALI_TEST_CHECK( value.Get<float>() == 0.f );
+ DALI_TEST_CHECK(value.GetType() == Property::FLOAT);
+ DALI_TEST_CHECK(value.Get<float>() == 0.f);
END_TEST;
}
{
Property::Value value(1);
- DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
- DALI_TEST_CHECK( value.Get<int>() == 1 );
+ DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
+ DALI_TEST_CHECK(value.Get<int>() == 1);
END_TEST;
}
{
Property::Value value(Property::INTEGER);
- DALI_TEST_CHECK( value.GetType() == Property::INTEGER );
- DALI_TEST_CHECK( value.Get<int>() == 0 );
+ DALI_TEST_CHECK(value.GetType() == Property::INTEGER);
+ DALI_TEST_CHECK(value.Get<int>() == 0);
END_TEST;
}
int UtcDaliPropertyValueConstructorsVector2P(void)
{
- Vector2 v(1,1);
+ Vector2 v(1, 1);
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
- DALI_TEST_CHECK( value.Get<Vector2>() == v );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
+ DALI_TEST_CHECK(value.Get<Vector2>() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsVector2TypeP(void)
{
- Property::Value value( Property::VECTOR2 );
+ Property::Value value(Property::VECTOR2);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR2 );
- DALI_TEST_CHECK( value.Get<Vector2>() == Vector2::ZERO );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR2);
+ DALI_TEST_CHECK(value.Get<Vector2>() == Vector2::ZERO);
END_TEST;
}
int UtcDaliPropertyValueConstructorsVector3P(void)
{
- Vector3 v(1.f,2.f,3.f);
+ Vector3 v(1.f, 2.f, 3.f);
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
- DALI_TEST_CHECK( value.Get<Vector3>() == v );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
+ DALI_TEST_CHECK(value.Get<Vector3>() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsVector3TypeP(void)
{
- Property::Value value( Property::VECTOR3 );
+ Property::Value value(Property::VECTOR3);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR3 );
- DALI_TEST_CHECK( value.Get<Vector3>() == Vector3() );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR3);
+ DALI_TEST_CHECK(value.Get<Vector3>() == Vector3());
END_TEST;
}
int UtcDaliPropertyValueConstructorsVector4P(void)
{
- Vector4 v(1.f,1.f,1.f,0.9f);
+ Vector4 v(1.f, 1.f, 1.f, 0.9f);
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
- DALI_TEST_CHECK( value.Get<Vector4>() == v );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+ DALI_TEST_CHECK(value.Get<Vector4>() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsVector4TypeP(void)
{
- Property::Value value( Property::VECTOR4 );
+ Property::Value value(Property::VECTOR4);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
- DALI_TEST_CHECK( value.Get<Vector4>() == Vector4() );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+ DALI_TEST_CHECK(value.Get<Vector4>() == Vector4());
END_TEST;
}
int UtcDaliPropertyValueConstructorsMatrix3P(void)
{
- Matrix3 v(1.0,1.0,1.0, 1.0,1.0,1.0, 1.0,1.0,1.0);
+ Matrix3 v(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0);
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
- DALI_TEST_CHECK( value.Get<Matrix3>() == v );
+ DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
+ DALI_TEST_CHECK(value.Get<Matrix3>() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsMatrix3TypeP(void)
{
- Property::Value value( Property::MATRIX3 );
+ Property::Value value(Property::MATRIX3);
- DALI_TEST_CHECK( value.GetType() == Property::MATRIX3 );
- DALI_TEST_CHECK( value.Get<Matrix3>() == Matrix3() );
+ DALI_TEST_CHECK(value.GetType() == Property::MATRIX3);
+ DALI_TEST_CHECK(value.Get<Matrix3>() == Matrix3());
END_TEST;
}
int UtcDaliPropertyValueConstructorsMatrixP(void)
{
- float a[] = {1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0, 1.0,1.0,1.0,1.0};
- Matrix v(a);
+ float a[] = {1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0};
+ Matrix v(a);
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
- DALI_TEST_CHECK( value.Get<Matrix>() == v );
+ DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
+ DALI_TEST_CHECK(value.Get<Matrix>() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsMatrixTypeP(void)
{
- Property::Value value( Property::MATRIX );
+ Property::Value value(Property::MATRIX);
- DALI_TEST_CHECK( value.GetType() == Property::MATRIX );
- DALI_TEST_CHECK( value.Get<Matrix>() == Matrix() );
+ DALI_TEST_CHECK(value.GetType() == Property::MATRIX);
+ DALI_TEST_CHECK(value.Get<Matrix>() == Matrix());
END_TEST;
}
int UtcDaliPropertyValueConstructorsRectP(void)
{
- Rect<int> v(1.0,1.0,1.0,1.0);
+ Rect<int> v(1.0, 1.0, 1.0, 1.0);
Property::Value value(v);
- DALI_TEST_EQUALS( value.GetType(), Property::RECTANGLE, TEST_LOCATION );
- DALI_TEST_CHECK( value.Get<Rect<int> >() == v );
+ DALI_TEST_EQUALS(value.GetType(), Property::RECTANGLE, TEST_LOCATION);
+ DALI_TEST_CHECK(value.Get<Rect<int> >() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsRectTypeP(void)
{
- Property::Value value( Property::RECTANGLE );
+ Property::Value value(Property::RECTANGLE);
- DALI_TEST_CHECK( value.GetType() == Property::RECTANGLE );
- DALI_TEST_CHECK( value.Get<Rect<int> >() == Rect<int>(0,0,0,0) );
+ DALI_TEST_CHECK(value.GetType() == Property::RECTANGLE);
+ DALI_TEST_CHECK(value.Get<Rect<int> >() == Rect<int>(0, 0, 0, 0));
END_TEST;
}
int UtcDaliPropertyValueConstructorsAngleAxisP(void)
{
- AngleAxis input( Dali::ANGLE_90, Vector3::XAXIS );
- Property::Value value( input );
+ AngleAxis input(Dali::ANGLE_90, Vector3::XAXIS);
+ Property::Value value(input);
- DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
+ DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
AngleAxis result = value.Get<AngleAxis>();
- DALI_TEST_EQUALS( result.angle, input.angle, TEST_LOCATION );
- DALI_TEST_EQUALS( result.axis, input.axis, TEST_LOCATION );
+ DALI_TEST_EQUALS(result.angle, input.angle, TEST_LOCATION);
+ DALI_TEST_EQUALS(result.axis, input.axis, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueConstructorsQuaternionP(void)
{
- Quaternion v( Radian( Math::PI ), Vector3::ZAXIS );
+ Quaternion v(Radian(Math::PI), Vector3::ZAXIS);
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
- DALI_TEST_EQUALS( v, value.Get<Quaternion>(), 0.001, TEST_LOCATION);
+ DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
+ DALI_TEST_EQUALS(v, value.Get<Quaternion>(), 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueConstructorsRotationTypeP(void)
{
- Property::Value value( Property::ROTATION );
+ Property::Value value(Property::ROTATION);
- DALI_TEST_CHECK( value.GetType() == Property::ROTATION );
+ DALI_TEST_CHECK(value.GetType() == Property::ROTATION);
AngleAxis result = value.Get<AngleAxis>();
- DALI_TEST_EQUALS( result.angle, Radian(0.f), TEST_LOCATION );
- DALI_TEST_EQUALS( result.axis, Vector3::ZERO, TEST_LOCATION ); // identity quaternion returns a zero angle-axis
+ DALI_TEST_EQUALS(result.angle, Radian(0.f), TEST_LOCATION);
+ DALI_TEST_EQUALS(result.axis, Vector3::ZERO, TEST_LOCATION); // identity quaternion returns a zero angle-axis
END_TEST;
}
int UtcDaliPropertyValueConstructorsStringP(void)
{
- std::string v("1");
+ std::string v("1");
Property::Value value(v);
- DALI_TEST_CHECK( value.GetType() == Property::STRING );
- DALI_TEST_CHECK( value.Get<std::string>() == v );
+ DALI_TEST_CHECK(value.GetType() == Property::STRING);
+ DALI_TEST_CHECK(value.Get<std::string>() == v);
END_TEST;
}
int UtcDaliPropertyValueConstructorsStringTypeP(void)
{
- Property::Value value( Property::STRING );
+ Property::Value value(Property::STRING);
- DALI_TEST_CHECK( value.GetType() == Property::STRING );
- DALI_TEST_CHECK( value.Get<std::string>() == std::string() );
+ DALI_TEST_CHECK(value.GetType() == Property::STRING);
+ DALI_TEST_CHECK(value.Get<std::string>() == std::string());
END_TEST;
}
int UtcDaliPropertyValueConstructorsArrayP(void)
{
Property::Array foo;
- Property::Value value( foo );
+ Property::Value value(foo);
- DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
- DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 0 );
+ DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+ DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
END_TEST;
}
int UtcDaliPropertyValueConstructorsArray2P(void)
{
Property::Array foo;
- foo.PushBack( Property::Value() );
- Property::Value value( foo );
+ foo.PushBack(Property::Value());
+ Property::Value value(foo);
- DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
- DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 1 );
+ DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+ DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 1);
END_TEST;
}
{
Property::Value value(Property::ARRAY);
- DALI_TEST_CHECK( value.GetType() == Property::ARRAY );
- DALI_TEST_CHECK( value.Get<Property::Array>().Count() == 0 );
+ DALI_TEST_CHECK(value.GetType() == Property::ARRAY);
+ DALI_TEST_CHECK(value.Get<Property::Array>().Count() == 0);
END_TEST;
}
int UtcDaliPropertyValueConstructorsMapP(void)
{
- Property::Map map;
- Property::Value value( map );
+ Property::Map map;
+ Property::Value value(map);
- DALI_TEST_CHECK( value.GetType() == Property::MAP );
- DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 0 );
+ DALI_TEST_CHECK(value.GetType() == Property::MAP);
+ DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
END_TEST;
}
int UtcDaliPropertyValueConstructorsMap2P(void)
{
Property::Map map;
- map.Insert( "", "" );
- Property::Value value( map );
+ map.Insert("", "");
+ Property::Value value(map);
- DALI_TEST_CHECK( value.GetType() == Property::MAP );
- DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 1 );
+ DALI_TEST_CHECK(value.GetType() == Property::MAP);
+ DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 1);
END_TEST;
}
{
Property::Value value(Property::MAP);
- DALI_TEST_CHECK( value.GetType() == Property::MAP );
- DALI_TEST_CHECK( value.Get<Property::Map>().Count() == 0 );
+ DALI_TEST_CHECK(value.GetType() == Property::MAP);
+ DALI_TEST_CHECK(value.Get<Property::Map>().Count() == 0);
END_TEST;
}
int UtcDaliPropertyValueConstructorsExtentsTypeP(void)
{
- Property::Value value( Property::EXTENTS );
+ Property::Value value(Property::EXTENTS);
- DALI_TEST_CHECK( value.GetType() == Property::EXTENTS );
- DALI_TEST_CHECK( value.Get<Extents>() == Extents( 0u, 0u, 0u, 0u ) );
+ DALI_TEST_CHECK(value.GetType() == Property::EXTENTS);
+ DALI_TEST_CHECK(value.Get<Extents>() == Extents(0u, 0u, 0u, 0u));
END_TEST;
}
int UtcDaliPropertyValueConstructorsExtentsType2P(void)
{
- Property::Value value( Property::VECTOR4 );
+ Property::Value value(Property::VECTOR4);
- DALI_TEST_CHECK( value.GetType() == Property::VECTOR4 );
- DALI_TEST_CHECK( value.Get<Extents>() == Extents( 0u, 0u, 0u, 0u ) );
+ DALI_TEST_CHECK(value.GetType() == Property::VECTOR4);
+ DALI_TEST_CHECK(value.Get<Extents>() == Extents(0u, 0u, 0u, 0u));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorP(void)
{
Property::Value value;
- Property::Value value2( value );
- DALI_TEST_EQUALS( value.GetType(), value2.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( value.GetMap(), value2.GetMap(), TEST_LOCATION );
- DALI_TEST_EQUALS( value.GetArray(), value2.GetArray(), TEST_LOCATION );
+ Property::Value value2(value);
+ DALI_TEST_EQUALS(value.GetType(), value2.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(value.GetMap(), value2.GetMap(), TEST_LOCATION);
+ DALI_TEST_EQUALS(value.GetArray(), value2.GetArray(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueCopyConstructoVector2P(void)
{
- CheckCopyCtorP<Vector2> check( Vector2(2,1) );
+ CheckCopyCtorP<Vector2> check(Vector2(2, 1));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorVector3P(void)
{
- CheckCopyCtorP<Vector3> check( Vector3(3.f,2.f,1.f) );
+ CheckCopyCtorP<Vector3> check(Vector3(3.f, 2.f, 1.f));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorVector4P(void)
{
- CheckCopyCtorP<Vector3> check( Vector4(4.f,3.f,2.f,1.f) );
+ CheckCopyCtorP<Vector3> check(Vector4(4.f, 3.f, 2.f, 1.f));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorMatrix3P(void)
{
- CheckCopyCtorP<Matrix3> check( Matrix3::IDENTITY );
+ CheckCopyCtorP<Matrix3> check(Matrix3::IDENTITY);
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorRectP(void)
{
- CheckCopyCtorP<Rect<int> > check( Rect<int>(1.0,1.0,1.0,1.0) );
+ CheckCopyCtorP<Rect<int> > check(Rect<int>(1.0, 1.0, 1.0, 1.0));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorAngleAxisP(void)
{
- CheckCopyCtorP<AngleAxis> check( AngleAxis(Degree(1.0), Vector3(1.0,1.0,1.0)) );
+ CheckCopyCtorP<AngleAxis> check(AngleAxis(Degree(1.0), Vector3(1.0, 1.0, 1.0)));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorQuaternionP(void)
{
- CheckCopyCtorP<Quaternion> check( Quaternion( Vector4(1.0, 1.0, 1.0, 1.0) ) );
+ CheckCopyCtorP<Quaternion> check(Quaternion(Vector4(1.0, 1.0, 1.0, 1.0)));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorStringP(void)
{
- CheckCopyCtorP<std::string> check( std::string("1") );
+ CheckCopyCtorP<std::string> check(std::string("1"));
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorArrayP(void)
{
- Property::Value value1(Property::ARRAY);
- Property::Array* array= value1.GetArray();
+ Property::Value value1(Property::ARRAY);
+ Property::Array* array = value1.GetArray();
array->PushBack(Property::Value(1));
- Property::Value value2( value1 );
- DALI_TEST_EQUALS( value1.GetType(), value2.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION );
+ Property::Value value2(value1);
+ DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(value1.GetArray()->Count(), value2.GetArray()->Count(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueCopyConstructorMapP(void)
{
Property::Value value1(Property::MAP);
- Property::Map* map = value1.GetMap();
- (*map)["1"] = Property::Value(1);
+ Property::Map* map = value1.GetMap();
+ (*map)["1"] = Property::Value(1);
- Property::Value value2( value1 );
- DALI_TEST_EQUALS( value1.GetType(), value2.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( value1.GetMap()->GetKey( 0 ), value2.GetMap()->GetKey( 0 ), TEST_LOCATION );
+ Property::Value value2(value1);
+ DALI_TEST_EQUALS(value1.GetType(), value2.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(value1.GetMap()->Count(), value2.GetMap()->Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(value1.GetMap()->GetKey(0), value2.GetMap()->GetKey(0), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueMoveConstructor(void)
{
- Property::Value value1( Vector4::ONE );
- DALI_TEST_EQUALS( Property::VECTOR4, value1.GetType(), TEST_LOCATION );
+ Property::Value value1(Vector4::ONE);
+ DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
Vector4 valueVector;
- DALI_TEST_EQUALS( true, value1.Get( valueVector ), TEST_LOCATION ); // Able to convert
- DALI_TEST_EQUALS( valueVector, Vector4::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
+ DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
- Property::Value value2( std::move( value1 ) );
- DALI_TEST_EQUALS( Property::NONE, value1.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value1.Get( valueVector ), TEST_LOCATION ); // Unable to convert, but no crash either
- DALI_TEST_EQUALS( Property::VECTOR4, value2.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value2.Get( valueVector ), TEST_LOCATION ); // Able to convert
- DALI_TEST_EQUALS( valueVector, Vector4::ONE, TEST_LOCATION );
+ Property::Value value2(std::move(value1));
+ DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
+ DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
+ DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueMoveConstructorArray(void)
{
Property::Array array;
- array.PushBack( 1 );
- array.PushBack( 2 );
- array.PushBack( 3 );
- DALI_TEST_EQUALS( 3u, array.Size(), TEST_LOCATION );
+ array.PushBack(1);
+ array.PushBack(2);
+ array.PushBack(3);
+ DALI_TEST_EQUALS(3u, array.Size(), TEST_LOCATION);
- Property::Value value( std::move( array ) );
- DALI_TEST_ASSERTION( array.Size(), "Cannot use an object previously used as an r-value" ); // Our local variable should become invalid
+ Property::Value value(std::move(array));
+ DALI_TEST_ASSERTION(array.Size(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
Property::Array* arrayPtr = value.GetArray();
- DALI_TEST_CHECK( arrayPtr );
- DALI_TEST_EQUALS( 3u, arrayPtr->Size(), TEST_LOCATION );
+ DALI_TEST_CHECK(arrayPtr);
+ DALI_TEST_EQUALS(3u, arrayPtr->Size(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueMoveConstructorMap(void)
{
Property::Map map;
- map[ 1 ] = 1;
- map[ 2 ] = 2;
- map[ 3 ] = 3;
- DALI_TEST_EQUALS( 3u, map.Count(), TEST_LOCATION );
+ map[1] = 1;
+ map[2] = 2;
+ map[3] = 3;
+ DALI_TEST_EQUALS(3u, map.Count(), TEST_LOCATION);
- Property::Value value( std::move( map ) );
- DALI_TEST_ASSERTION( map.Count(), "Cannot use an object previously used as an r-value" ); // Our local variable should become invalid
+ Property::Value value(std::move(map));
+ DALI_TEST_ASSERTION(map.Count(), "Cannot use an object previously used as an r-value"); // Our local variable should become invalid
Property::Map* mapPtr = value.GetMap();
- DALI_TEST_CHECK( mapPtr );
- DALI_TEST_EQUALS( 3u, mapPtr->Count(), TEST_LOCATION );
+ DALI_TEST_CHECK(mapPtr);
+ DALI_TEST_EQUALS(3u, mapPtr->Count(), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueAssignmentSelfP(void)
{
- Property::Value value;
+ Property::Value value;
Property::Value* self = &value;
- value = *self;
- DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
- DALI_TEST_CHECK( value.GetMap() == NULL );
- DALI_TEST_CHECK( value.GetArray() == NULL );
+ value = *self;
+ DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
+ DALI_TEST_CHECK(value.GetMap() == NULL);
+ DALI_TEST_CHECK(value.GetArray() == NULL);
END_TEST;
}
{
Property::Value value;
value = Property::Value(); // type match
- DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
- Property::Value copy( false );
+ DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
+ Property::Value copy(false);
copy = value; // type mismatch
- DALI_TEST_EQUALS( value.GetType(), Property::NONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(value.GetType(), Property::NONE, TEST_LOCATION);
END_TEST;
}
{
Property::Value value;
value = Property::Value(true); // type mismatch
- DALI_TEST_CHECK( true == value.Get<bool>() );
- Property::Value copy( false );
+ DALI_TEST_CHECK(true == value.Get<bool>());
+ Property::Value copy(false);
copy = value; // type match
- DALI_TEST_CHECK( true == copy.Get<bool>() );
+ DALI_TEST_CHECK(true == copy.Get<bool>());
END_TEST;
}
{
Property::Value value;
value = Property::Value(10); // type mismatch
- DALI_TEST_CHECK( 10 == value.Get<int>() );
- Property::Value copy( 99 );
+ DALI_TEST_CHECK(10 == value.Get<int>());
+ Property::Value copy(99);
copy = value; // type match
- DALI_TEST_CHECK( 10 == copy.Get<int>() );
+ DALI_TEST_CHECK(10 == copy.Get<int>());
END_TEST;
}
{
Property::Value value;
value = Property::Value(10.f); // mismatch
- DALI_TEST_CHECK( Dali::Equals(10.f, value.Get<float>() ) );
+ DALI_TEST_CHECK(Dali::Equals(10.f, value.Get<float>()));
Property::Value copy(321.f);
copy = value; // match
- DALI_TEST_CHECK( Dali::Equals(10.f, copy.Get<float>() ) );
+ DALI_TEST_CHECK(Dali::Equals(10.f, copy.Get<float>()));
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorVector2P(void)
{
Property::Value value;
- value = Property::Value( Vector2(1,2) ); // mismatch
- DALI_TEST_CHECK( Vector2(1,2) == value.Get<Vector2>() );
- Property::Value copy( Property::VECTOR2 );
+ value = Property::Value(Vector2(1, 2)); // mismatch
+ DALI_TEST_CHECK(Vector2(1, 2) == value.Get<Vector2>());
+ Property::Value copy(Property::VECTOR2);
copy = value; // match
- DALI_TEST_CHECK( Vector2(1,2) == copy.Get<Vector2>() );
+ DALI_TEST_CHECK(Vector2(1, 2) == copy.Get<Vector2>());
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorVector3P(void)
{
Property::Value value;
- value = Property::Value( Vector3(1.f,2.f,3.f) ); // mismatch
- DALI_TEST_CHECK( Vector3(1.f,2.f,3.f) == value.Get<Vector3>() );
- Property::Value copy( Property::VECTOR3 );
+ value = Property::Value(Vector3(1.f, 2.f, 3.f)); // mismatch
+ DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == value.Get<Vector3>());
+ Property::Value copy(Property::VECTOR3);
copy = value; // match
- DALI_TEST_CHECK( Vector3(1.f,2.f,3.f) == copy.Get<Vector3>() );
+ DALI_TEST_CHECK(Vector3(1.f, 2.f, 3.f) == copy.Get<Vector3>());
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorVector4P(void)
{
Property::Value value;
- value = Property::Value( Vector4(1,2,3,4) ); // mismatch
- DALI_TEST_CHECK( Vector4(1,2,3,4) == value.Get<Vector4>() );
- Property::Value copy( Vector4(0,1,2,3) );
+ value = Property::Value(Vector4(1, 2, 3, 4)); // mismatch
+ DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == value.Get<Vector4>());
+ Property::Value copy(Vector4(0, 1, 2, 3));
copy = value; // match
- DALI_TEST_CHECK( Vector4(1,2,3,4) == copy.Get<Vector4>() );
+ DALI_TEST_CHECK(Vector4(1, 2, 3, 4) == copy.Get<Vector4>());
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorMatrix3P(void)
{
Property::Value value;
- value = Property::Value( Matrix3::IDENTITY ); // mismatch
- DALI_TEST_CHECK( Matrix3::IDENTITY == value.Get<Matrix3>() );
- Property::Value copy( Property::MATRIX3 );
+ value = Property::Value(Matrix3::IDENTITY); // mismatch
+ DALI_TEST_CHECK(Matrix3::IDENTITY == value.Get<Matrix3>());
+ Property::Value copy(Property::MATRIX3);
copy = value; // match
- DALI_TEST_CHECK( Matrix3::IDENTITY == copy.Get<Matrix3>() );
+ DALI_TEST_CHECK(Matrix3::IDENTITY == copy.Get<Matrix3>());
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorMatrixP(void)
{
Property::Value value;
- value = Property::Value( Matrix::IDENTITY ); // mismatch
- DALI_TEST_CHECK( Matrix::IDENTITY == value.Get<Matrix>() );
- Matrix foo;
- Property::Value copy( foo );
+ value = Property::Value(Matrix::IDENTITY); // mismatch
+ DALI_TEST_CHECK(Matrix::IDENTITY == value.Get<Matrix>());
+ Matrix foo;
+ Property::Value copy(foo);
copy = value; // match
- DALI_TEST_CHECK( Matrix::IDENTITY == copy.Get<Matrix>() );
+ DALI_TEST_CHECK(Matrix::IDENTITY == copy.Get<Matrix>());
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorRectP(void)
{
- Property::Value value;
+ Property::Value value;
typedef Dali::Rect<int> Rectangle;
- value = Property::Value( Rectangle(4,3,2,1) ); // mismatch
- DALI_TEST_CHECK( Rectangle(4,3,2,1) == value.Get<Rectangle>() );
- Property::Value copy( Property::RECTANGLE );
+ value = Property::Value(Rectangle(4, 3, 2, 1)); // mismatch
+ DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == value.Get<Rectangle>());
+ Property::Value copy(Property::RECTANGLE);
copy = value; // match
Rectangle copyRect;
copy.Get(copyRect);
- DALI_TEST_CHECK( Rectangle(4,3,2,1) == copyRect );
+ DALI_TEST_CHECK(Rectangle(4, 3, 2, 1) == copyRect);
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorQuaternionP(void)
{
Property::Value value;
- Quaternion result( Radian( Math::PI_2 ), Vector3::YAXIS );
- value = Property::Value( result );
+ Quaternion result(Radian(Math::PI_2), Vector3::YAXIS);
+ value = Property::Value(result);
- DALI_TEST_EQUALS( value.Get<Quaternion>(), result, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(value.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
- Property::Value copy( Property::ROTATION );
+ Property::Value copy(Property::ROTATION);
copy = value; // match
- DALI_TEST_EQUALS( copy.Get<Quaternion>(), result, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(copy.Get<Quaternion>(), result, 0.001, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliPropertyValueAssignmentOperatorAngleAxisP(void)
{
Property::Value value;
- value = Property::Value( AngleAxis( Radian(Math::PI_2), Vector3::XAXIS ) ); // mismatch
- DALI_TEST_EQUALS( value.Get<AngleAxis>().axis, Vector3::XAXIS, TEST_LOCATION );
- DALI_TEST_EQUALS( value.Get<AngleAxis>().angle, Radian(Math::PI_2), TEST_LOCATION );
- Property::Value copy( Property::ROTATION );
+ value = Property::Value(AngleAxis(Radian(Math::PI_2), Vector3::XAXIS)); // mismatch
+ DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, Vector3::XAXIS, TEST_LOCATION);
+ DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, Radian(Math::PI_2), TEST_LOCATION);
+ Property::Value copy(Property::ROTATION);
copy = value; // match
- DALI_TEST_EQUALS( value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION );
- DALI_TEST_EQUALS( value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION );
+ DALI_TEST_EQUALS(value.Get<AngleAxis>().axis, copy.Get<AngleAxis>().axis, TEST_LOCATION);
+ DALI_TEST_EQUALS(value.Get<AngleAxis>().angle, copy.Get<AngleAxis>().angle, TEST_LOCATION);
END_TEST;
}
{
Property::Value value;
value = Property::Value("yes"); // mismatch
- DALI_TEST_CHECK( "yes" == value.Get<std::string>() );
+ DALI_TEST_CHECK("yes" == value.Get<std::string>());
Property::Value copy("no");
copy = value; // match
- DALI_TEST_CHECK( "yes" == copy.Get<std::string>() );
+ DALI_TEST_CHECK("yes" == copy.Get<std::string>());
END_TEST;
}
Property::Value value;
value = Property::Value(Property::ARRAY); // mismatch
value.GetArray()->PushBack(10);
- DALI_TEST_CHECK( value.GetArray() );
+ DALI_TEST_CHECK(value.GetArray());
Property::Value copy(Property::ARRAY);
copy = value; // match
Property::Array array;
- copy.Get( array );
+ copy.Get(array);
int getItem = 0;
- array[0].Get( getItem );
- DALI_TEST_CHECK( getItem == 10 );
+ array[0].Get(getItem);
+ DALI_TEST_CHECK(getItem == 10);
END_TEST;
}
Property::Value value;
value = Property::Value(Property::MAP); // mismatch
value.GetMap()->Insert("key", "value");
- Property::Value copy( Property::MAP ); // match
+ Property::Value copy(Property::MAP); // match
copy = value;
Property::Map map;
- copy.Get( map );
- DALI_TEST_CHECK( map.GetKey(0) == "key" );
+ copy.Get(map);
+ DALI_TEST_CHECK(map.GetKey(0) == "key");
END_TEST;
}
int UtcDaliPropertyValueAssignmentOperatorExtentsP(void)
{
Property::Value value;
- value = Property::Value( Extents( 4, 3, 2, 1 ) ); // mismatch
- DALI_TEST_CHECK( Extents( 4, 3, 2, 1 ) == value.Get<Extents>() );
- Property::Value copy( Property::EXTENTS );
+ value = Property::Value(Extents(4, 3, 2, 1)); // mismatch
+ DALI_TEST_CHECK(Extents(4, 3, 2, 1) == value.Get<Extents>());
+ Property::Value copy(Property::EXTENTS);
copy = value; // match
Extents copyExtents;
copy.Get(copyExtents);
- DALI_TEST_CHECK( Extents( 4, 3, 2, 1 ) == copyExtents );
+ DALI_TEST_CHECK(Extents(4, 3, 2, 1) == copyExtents);
END_TEST;
}
int UtcDaliPropertyValueMoveAssignmentOperator(void)
{
- Property::Value value1( Vector4::ONE );
- DALI_TEST_EQUALS( Property::VECTOR4, value1.GetType(), TEST_LOCATION );
+ Property::Value value1(Vector4::ONE);
+ DALI_TEST_EQUALS(Property::VECTOR4, value1.GetType(), TEST_LOCATION);
Vector4 valueVector;
- DALI_TEST_EQUALS( true, value1.Get( valueVector ), TEST_LOCATION ); // Able to convert
- DALI_TEST_EQUALS( valueVector, Vector4::ONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value1.Get(valueVector), TEST_LOCATION); // Able to convert
+ DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
Property::Value value2;
- value2 = std::move( value1 );
- DALI_TEST_EQUALS( Property::NONE, value1.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value1.Get( valueVector ), TEST_LOCATION ); // Unable to convert, but no crash either
- DALI_TEST_EQUALS( Property::VECTOR4, value2.GetType(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value2.Get( valueVector ), TEST_LOCATION ); // Able to convert
- DALI_TEST_EQUALS( valueVector, Vector4::ONE, TEST_LOCATION );
+ value2 = std::move(value1);
+ DALI_TEST_EQUALS(Property::NONE, value1.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value1.Get(valueVector), TEST_LOCATION); // Unable to convert, but no crash either
+ DALI_TEST_EQUALS(Property::VECTOR4, value2.GetType(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value2.Get(valueVector), TEST_LOCATION); // Able to convert
+ DALI_TEST_EQUALS(valueVector, Vector4::ONE, TEST_LOCATION);
// Change to another value type
- value2 = std::move( Property::Value( 1.0f ) );
- DALI_TEST_EQUALS( false, value2.Get( valueVector ), TEST_LOCATION ); // Should not be able to convert to a Vector4 now
+ value2 = std::move(Property::Value(1.0f));
+ DALI_TEST_EQUALS(false, value2.Get(valueVector), TEST_LOCATION); // Should not be able to convert to a Vector4 now
float valueFloat;
- DALI_TEST_EQUALS( true, value2.Get( valueFloat ), TEST_LOCATION ); // Should be able to convert to a float now
- DALI_TEST_EQUALS( valueFloat, 1.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION); // Should be able to convert to a float now
+ DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
// Ensure self assignment doesn't do anything silly
- value2 = std::move( value2 );
- DALI_TEST_EQUALS( true, value2.Get( valueFloat ), TEST_LOCATION );
- DALI_TEST_EQUALS( valueFloat, 1.0f, TEST_LOCATION );
+ value2 = std::move(value2);
+ DALI_TEST_EQUALS(true, value2.Get(valueFloat), TEST_LOCATION);
+ DALI_TEST_EQUALS(valueFloat, 1.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetTypeP(void)
{
Property::Value value;
- DALI_TEST_CHECK( value.GetType() == Property::NONE );
+ DALI_TEST_CHECK(value.GetType() == Property::NONE);
END_TEST;
}
int UtcDaliPropertyValueGetBoolP(void)
{
Property::Value value(true);
- bool boolean( false );
- DALI_TEST_CHECK( value.Get( boolean ) == true );
- DALI_TEST_CHECK( value.Get<bool>() == true );
+ bool boolean(false);
+ DALI_TEST_CHECK(value.Get(boolean) == true);
+ DALI_TEST_CHECK(value.Get<bool>() == true);
std::string string;
- DALI_TEST_CHECK( value.Get( string ) == false );
+ DALI_TEST_CHECK(value.Get(string) == false);
value = Property::Value(1.f);
- DALI_TEST_CHECK( value.Get<float>() == 1.f );
+ DALI_TEST_CHECK(value.Get<float>() == 1.f);
END_TEST;
}
int UtcDaliPropertyValueGetBoolN(void)
{
Property::Value value;
- DALI_TEST_CHECK( value.Get<bool>() == false );
- bool boolean( false );
- DALI_TEST_CHECK( value.Get( boolean ) == false );
+ DALI_TEST_CHECK(value.Get<bool>() == false);
+ bool boolean(false);
+ DALI_TEST_CHECK(value.Get(boolean) == false);
END_TEST;
}
int UtcDaliPropertyValueGetFloatP(void)
{
Property::Value value(1.1f);
- float flow( 0.0f );
- DALI_TEST_EQUALS( 1.1f, value.Get<float>(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( flow ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.1f, flow, TEST_LOCATION );
+ float flow(0.0f);
+ DALI_TEST_EQUALS(1.1f, value.Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(flow), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.1f, flow, TEST_LOCATION);
Property::Value intValue(100);
- DALI_TEST_EQUALS( 100.f, intValue.Get<float>(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, intValue.Get( flow ), TEST_LOCATION );
- DALI_TEST_EQUALS( 100.f, flow, TEST_LOCATION );
+ DALI_TEST_EQUALS(100.f, intValue.Get<float>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, intValue.Get(flow), TEST_LOCATION);
+ DALI_TEST_EQUALS(100.f, flow, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetFloatN(void)
{
Property::Value value;
- float result( 1.0f );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.0f, result, TEST_LOCATION ); // result is not modified
- Property::Value value2( "" );
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1.0f, result, TEST_LOCATION ); // result is not modified
+ float result(1.0f);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
+ Property::Value value2("");
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(1.0f, result, TEST_LOCATION); // result is not modified
END_TEST;
}
int UtcDaliPropertyValueGetIntP(void)
{
Property::Value value(123);
- int result( 10 );
- DALI_TEST_EQUALS( 123, value.Get<int>(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 123, result, TEST_LOCATION );
+ int result(10);
+ DALI_TEST_EQUALS(123, value.Get<int>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(123, result, TEST_LOCATION);
Property::Value floatValue(21.f);
- DALI_TEST_EQUALS( 21, floatValue.Get<int>(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, floatValue.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 21, result, TEST_LOCATION );
+ DALI_TEST_EQUALS(21, floatValue.Get<int>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, floatValue.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(21, result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetIntN(void)
{
Property::Value value;
- int result( 10 );
- DALI_TEST_EQUALS( 0, value.Get<int>(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 10, result, TEST_LOCATION ); // result is not modified
+ int result(10);
+ DALI_TEST_EQUALS(0, value.Get<int>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 10, result, TEST_LOCATION ); // result is not modified
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(10, result, TEST_LOCATION); // result is not modified
END_TEST;
}
int UtcDaliPropertyValueGetRectP(void)
{
- Property::Value value( Rect<int>(1,2,3,4) );
- Rect<int> result(4,3,2,1);
- DALI_TEST_EQUALS( Rect<int>(1,2,3,4), value.Get< Rect<int> >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Rect<int>(1,2,3,4), result, TEST_LOCATION );
+ Property::Value value(Rect<int>(1, 2, 3, 4));
+ Rect<int> result(4, 3, 2, 1);
+ DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), value.Get<Rect<int> >(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Rect<int>(1, 2, 3, 4), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetRectN(void)
{
Property::Value value;
- Rect<int> result(4,3,2,1);
- DALI_TEST_EQUALS( Rect<int>(0,0,0,0), value.Get< Rect<int> >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Rect<int>(4,3,2,1), result, TEST_LOCATION );
+ Rect<int> result(4, 3, 2, 1);
+ DALI_TEST_EQUALS(Rect<int>(0, 0, 0, 0), value.Get<Rect<int> >(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Rect<int>(4,3,2,1), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Rect<int>(4, 3, 2, 1), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector2P(void)
{
- Property::Value value( Vector2(1.0f,2.0f) );
- Vector2 result;
- DALI_TEST_EQUALS( Vector2(1.0f,2.0f), value.Get< Vector2 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2(1.0f,2.0f), result, TEST_LOCATION );
+ Property::Value value(Vector2(1.0f, 2.0f));
+ Vector2 result;
+ DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector2fromVector3P(void)
{
- Property::Value value( Vector3(1.f,2.f,3.f) );
- Vector2 result;
- DALI_TEST_EQUALS( Vector2(1.0f,2.0f), value.Get< Vector2 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2(1.0f,2.0f), result, TEST_LOCATION );
+ Property::Value value(Vector3(1.f, 2.f, 3.f));
+ Vector2 result;
+ DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector2fromVector4P(void)
{
- Property::Value value( Vector4(1.f,2.f,3.f,4.f) );
- Vector2 result;
- DALI_TEST_EQUALS( Vector2(1.0f,2.0f), value.Get< Vector2 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2(1.0f,2.0f), result, TEST_LOCATION );
+ Property::Value value(Vector4(1.f, 2.f, 3.f, 4.f));
+ Vector2 result;
+ DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), value.Get<Vector2>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(1.0f, 2.0f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector2N(void)
{
Property::Value value;
- Vector2 result;
- DALI_TEST_EQUALS( Vector2(0.f,0.f), value.Get< Vector2 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2(), result, TEST_LOCATION );
+ Vector2 result;
+ DALI_TEST_EQUALS(Vector2(0.f, 0.f), value.Get<Vector2>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2(), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector3P(void)
{
- Property::Value value( Vector3(1.0f,2.0f,-1.f) );
- Vector3 result;
- DALI_TEST_EQUALS( Vector3(1.0f,2.0f,-1.f), value.Get< Vector3 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3(1.0f,2.0f,-1.f), result, TEST_LOCATION );
+ Property::Value value(Vector3(1.0f, 2.0f, -1.f));
+ Vector3 result;
+ DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), value.Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, -1.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector3FromVector2P(void)
{
- Property::Value value( Vector2(1.0f,2.0f) );
- Vector3 result(99.f,88.f,77.f);
- DALI_TEST_EQUALS( Vector3(1.0f,2.0f,0.f), value.Get< Vector3 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3(1.0f,2.0f,0.f), result, TEST_LOCATION );
+ Property::Value value(Vector2(1.0f, 2.0f));
+ Vector3 result(99.f, 88.f, 77.f);
+ DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(1.0f, 2.0f, 0.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector3FromVector4P(void)
{
- Property::Value value( Vector4(4.f,3.f,2.f,1.f) );
- Vector3 result;
- DALI_TEST_EQUALS( Vector3(4.f,3.f,2.f), value.Get< Vector3 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3(4.f,3.f,2.f), result, TEST_LOCATION );
+ Property::Value value(Vector4(4.f, 3.f, 2.f, 1.f));
+ Vector3 result;
+ DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), value.Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(4.f, 3.f, 2.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector3N(void)
{
Property::Value value;
- Vector3 result;
- DALI_TEST_EQUALS( Vector3(0.f,0.f,0.f), value.Get< Vector3 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3(), result, TEST_LOCATION );
+ Vector3 result;
+ DALI_TEST_EQUALS(Vector3(0.f, 0.f, 0.f), value.Get<Vector3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3(), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector4P(void)
{
- Property::Value value( Vector4(1.f,2.f,-1.f,-3.f) );
- Vector4 result;
- DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,-3.f), value.Get< Vector4 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,-3.f), result, TEST_LOCATION );
+ Property::Value value(Vector4(1.f, 2.f, -1.f, -3.f));
+ Vector4 result;
+ DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), value.Get<Vector4>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, -3.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector4FromVector2P(void)
{
- Property::Value value( Vector2(-1.f,-3.f) );
- Vector4 result(99.f,88.f,77.f,66.f);
- DALI_TEST_EQUALS( Vector4(-1.f,-3.f,0.f,0.f), value.Get< Vector4 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector4(-1.f,-3.f,0.f,0.f), result, TEST_LOCATION );
+ Property::Value value(Vector2(-1.f, -3.f));
+ Vector4 result(99.f, 88.f, 77.f, 66.f);
+ DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector4(-1.f, -3.f, 0.f, 0.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector4FromVector3P(void)
{
- Property::Value value( Vector3(1.f,2.f,-1.f) );
- Vector4 result(99.f,88.f,77.f,66.f);
- DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,0.f), value.Get< Vector4 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector4(1.f,2.f,-1.f,0.f), result, TEST_LOCATION );
+ Property::Value value(Vector3(1.f, 2.f, -1.f));
+ Vector4 result(99.f, 88.f, 77.f, 66.f);
+ DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector4(1.f, 2.f, -1.f, 0.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetVector4N(void)
{
Property::Value value;
- Vector4 result;
- DALI_TEST_EQUALS( Vector4(0.f,0.f,0.f,0.f), value.Get< Vector4 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector4(), result, TEST_LOCATION );
+ Vector4 result;
+ DALI_TEST_EQUALS(Vector4(0.f, 0.f, 0.f, 0.f), value.Get<Vector4>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Vector4(), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector4(), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetMatrix3P(void)
{
- Property::Value value( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f) );
- Matrix3 result;
- DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), value.Get< Matrix3 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
+ Property::Value value(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f));
+ Matrix3 result;
+ DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), value.Get<Matrix3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetMatrix3N(void)
{
Property::Value value;
- Matrix3 result(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f);
- DALI_TEST_EQUALS( Matrix3(), value.Get< Matrix3 >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
+ Matrix3 result(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f);
+ DALI_TEST_EQUALS(Matrix3(), value.Get<Matrix3>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Matrix3(1.f,2.f,3.f,4.f,5.f,6.f,7.f,8.f,9.f), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Matrix3(1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f, 9.f), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetMatrixP(void)
{
- float matrixValues[16] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
- Matrix input( matrixValues );
- Property::Value value( input );
- Matrix result;
- DALI_TEST_EQUALS( input, value.Get< Matrix >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( input, result, TEST_LOCATION );
+ float matrixValues[16] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
+ Matrix input(matrixValues);
+ Property::Value value(input);
+ Matrix result;
+ DALI_TEST_EQUALS(input, value.Get<Matrix>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(input, result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetMatrixN(void)
{
Property::Value value;
- Matrix result( Matrix::IDENTITY );
- DALI_TEST_EQUALS( Matrix(), value.Get< Matrix >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Matrix::IDENTITY, result, TEST_LOCATION );
+ Matrix result(Matrix::IDENTITY);
+ DALI_TEST_EQUALS(Matrix(), value.Get<Matrix>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Matrix::IDENTITY, result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Matrix::IDENTITY, result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetAngleAxisP(void)
{
- AngleAxis input( Dali::ANGLE_90, Vector3::XAXIS );
- Property::Value value( input );
- AngleAxis result = value.Get<AngleAxis>();
- DALI_TEST_EQUALS( input.angle, result.angle, TEST_LOCATION );
- DALI_TEST_EQUALS( input.axis, result.axis, TEST_LOCATION );
+ AngleAxis input(Dali::ANGLE_90, Vector3::XAXIS);
+ Property::Value value(input);
+ AngleAxis
result = value.Get<AngleAxis>();
+ DALI_TEST_EQUALS(input.angle, result.angle, TEST_LOCATION);
+ DALI_TEST_EQUALS(input.axis, result.axis, TEST_LOCATION);
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( input, result, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(input, result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetAngleAxisN(void)
{
Property::Value value;
- AngleAxis b = value.Get<AngleAxis>();
- AngleAxis result;
- DALI_TEST_EQUALS( (Radian)0.f, b.angle, TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3::ZERO, b.axis, TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( AngleAxis(), result, TEST_LOCATION );
+ AngleAxis
b = value.Get<AngleAxis>();
+ AngleAxis result;
+ DALI_TEST_EQUALS((Radian)0.f, b.angle, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3::ZERO, b.axis, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( AngleAxis(), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(AngleAxis(), result, TEST_LOCATION);
END_TEST;
}
Vector3 axis(1, 1, 0);
axis.Normalize();
- Quaternion result( Radian( 1.f ), axis );
- Property::Value value( result );
+ Quaternion result(Radian(1.f), axis);
+ Property::Value value(result);
- DALI_TEST_EQUALS( result, value.Get< Quaternion >(), TEST_LOCATION );
+ DALI_TEST_EQUALS(result, value.Get<Quaternion>(), TEST_LOCATION);
Quaternion test2;
- DALI_TEST_EQUALS( true, value.Get( test2 ), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value.Get(test2), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetQuaternionN(void)
{
Property::Value value;
- Vector3 axis(1, 1, 0);
+ Vector3 axis(1, 1, 0);
axis.Normalize();
- Quaternion result( Radian( 1.f ), axis );
+ Quaternion result(Radian(1.f), axis);
Quaternion test(result);
- DALI_TEST_EQUALS( Quaternion(), value.Get< Quaternion >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( test ), TEST_LOCATION );
- DALI_TEST_EQUALS( test, result, TEST_LOCATION );
+ DALI_TEST_EQUALS(Quaternion(), value.Get<Quaternion>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(test), TEST_LOCATION);
+ DALI_TEST_EQUALS(test, result, TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( test ), TEST_LOCATION );
- DALI_TEST_EQUALS( test, result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(test), TEST_LOCATION);
+ DALI_TEST_EQUALS(test, result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetStringP(void)
{
- Property::Value value( std::string("hello") );
- std::string result;
- DALI_TEST_EQUALS( std::string("hello"), value.Get< std::string >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( std::string("hello"), result, TEST_LOCATION );
+ Property::Value value(std::string("hello"));
+ std::string result;
+ DALI_TEST_EQUALS(std::string("hello"), value.Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(std::string("hello"), result, TEST_LOCATION);
- Property::Value value2( "C hi!" );
- DALI_TEST_EQUALS( "C hi!", value2.Get< std::string >(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( "C hi!", result, TEST_LOCATION );
+ Property::Value value2("C hi!");
+ DALI_TEST_EQUALS("C hi!", value2.Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS("C hi!", result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetStringN(void)
{
Property::Value value;
- std::string result("doesn't change");
- DALI_TEST_EQUALS( std::string(), value.Get< std::string >(), TEST_LOCATION );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( "doesn't change", result, TEST_LOCATION );
+ std::string result("doesn't change");
+ DALI_TEST_EQUALS(std::string(), value.Get<std::string>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
Property::Value value2(10);
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( "doesn't change", result, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS("doesn't change", result, TEST_LOCATION);
Property::Value value3((char*)NULL);
- DALI_TEST_EQUALS( true, value3.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( std::string(), result, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value3.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(std::string(), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueGetArrayP(void)
{
- Property::Value value( Property::ARRAY );
- DALI_TEST_CHECK( NULL != value.GetArray() );
- value.GetArray()->PushBack( Property::Value(1) );
+ Property::Value value(Property::ARRAY);
+ DALI_TEST_CHECK(NULL != value.GetArray());
+ value.GetArray()->PushBack(Property::Value(1));
Property::Array got = value.Get<Property::Array>();
- DALI_TEST_CHECK( got[0].Get<int>() == 1);
+ DALI_TEST_CHECK(got[0].Get<int>() == 1);
Property::Array result;
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_CHECK( result[0].Get<int>() == 1);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_CHECK(result[0].Get<int>() == 1);
END_TEST;
}
int UtcDaliPropertyValueGetArrayN(void)
{
Property::Value value;
- DALI_TEST_CHECK( NULL == value.GetArray() );
+ DALI_TEST_CHECK(NULL == value.GetArray());
Property::Array result;
- result.PushBack( Property::Value( 10 ) );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION ); // array is not modified
+ result.PushBack(Property::Value(10));
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION ); // array is not modified
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
END_TEST;
}
int UtcDaliPropertyValueGetMapP(void)
{
Property::Value value(Property::MAP);
- DALI_TEST_CHECK( NULL == value.GetArray() );
- DALI_TEST_CHECK( NULL != value.GetMap() );
+ DALI_TEST_CHECK(NULL == value.GetArray());
+ DALI_TEST_CHECK(NULL != value.GetMap());
value.GetMap()->Insert("key", Property::Value(1));
Property::Map result = value.Get<Property::Map>();
DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
DALI_TEST_CHECK(result.Find("key")->Get<int>() == 1);
END_TEST;
}
int UtcDaliPropertyValueGetMapN(void)
{
Property::Value value;
- DALI_TEST_CHECK( NULL == value.GetMap() );
- DALI_TEST_EQUALS( 0u, value.Get<Property::Map>().Count(), TEST_LOCATION );
+ DALI_TEST_CHECK(NULL == value.GetMap());
+ DALI_TEST_EQUALS(0u, value.Get<Property::Map>().Count(), TEST_LOCATION);
Property::Map result;
- result.Insert("key", "value" );
- DALI_TEST_EQUALS( false, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION );
+ result.Insert("key", "value");
+ DALI_TEST_EQUALS(false, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION);
Property::Value value2("");
- DALI_TEST_EQUALS( false, value2.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, result.Count(), TEST_LOCATION ); // array is not modified
+ DALI_TEST_EQUALS(false, value2.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, result.Count(), TEST_LOCATION); // array is not modified
END_TEST;
}
int UtcDaliPropertyValueGetExtentsP(void)
{
- Property::Value value( Extents( 1u, 2u, 3u, 4u ) );
- Extents result( 4u, 3u, 2u, 1u );
- DALI_TEST_EQUALS( Extents( 1u, 2u, 3u, 4u ), value.Get<Extents>(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( Extents( 1u, 2u, 3u, 4u ), result, TEST_LOCATION );
+ Property::Value value(Extents(1u, 2u, 3u, 4u));
+ Extents result(4u, 3u, 2u, 1u);
+ DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), value.Get<Extents>(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(Extents(1u, 2u, 3u, 4u), result, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyValueEnum(void)
{
- enum class E { zero, e };
- Property::Value value( E::e );
- DALI_TEST_EQUALS( static_cast<int>(E::e), static_cast<int>(value.Get<E>()), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<int>(E::e), value.Get<int>(), TEST_LOCATION );
+ enum class E
+ {
+ zero,
+ e
+ };
+ Property::Value value(E::e);
+ DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(value.Get<E>()), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<int>(E::e), value.Get<int>(), TEST_LOCATION);
E result;
- DALI_TEST_EQUALS( true, value.Get( result ), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<int>(E::e), static_cast<int>(result), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value.Get(result), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<int>(E::e), static_cast<int>(result), TEST_LOCATION);
int result2;
- DALI_TEST_EQUALS( true, value.Get( result2 ), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<int>(E::e), result2, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, value.Get(result2), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<int>(E::e), result2, TEST_LOCATION);
END_TEST;
}
{
std::ostringstream stream;
stream << value;
- DALI_TEST_CHECK( stream.str() == "1" )
+ DALI_TEST_CHECK(stream.str() == "1")
}
{
- Property::Value empty;
+ Property::Value empty;
std::ostringstream stream;
stream << empty;
- DALI_TEST_EQUALS( stream.str(), "undefined type", TEST_LOCATION );
+ DALI_TEST_EQUALS(stream.str(), "undefined type", TEST_LOCATION);
}
{
- Property::Value empty( Property::NONE );
+ Property::Value empty(Property::NONE);
std::ostringstream stream;
stream << empty;
- DALI_TEST_CHECK( stream.str() == "undefined type" )
+ DALI_TEST_CHECK(stream.str() == "undefined type")
}
{
value = Property::Value(20.2f);
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "20.2" )
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "20.2")
}
{
value = Property::Value(-25);
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "-25" )
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "-25")
}
{
- value = Property::Value( Vector2(1.f,1.f) );
+ value = Property::Value(Vector2(1.f, 1.f));
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "[1, 1]" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "[1, 1]");
}
{
- value = Property::Value( Vector3(1.f,1.f,1.f) );
+ value = Property::Value(Vector3(1.f, 1.f, 1.f));
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "[1, 1, 1]" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "[1, 1, 1]");
}
{
- value = Property::Value( Vector4(-4.f,-3.f,-2.f,-1.f) );
+ value = Property::Value(Vector4(-4.f, -3.f, -2.f, -1.f));
std::ostringstream stream;
- stream << value;
- DALI_TEST_EQUALS( stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION );
+ stream << value;
+ DALI_TEST_EQUALS(stream.str(), "[-4, -3, -2, -1]", TEST_LOCATION);
}
{
- value = Property::Value( Matrix3::IDENTITY );
+ value = Property::Value(Matrix3::IDENTITY);
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 1, 0, 0, 0, 1 ]");
}
{
- value = Property::Value( Matrix::IDENTITY );
+ value = Property::Value(Matrix::IDENTITY);
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "[ 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 ]");
}
{
- value = Property::Value( Rectangle(1,2,3,4) );
+ value = Property::Value(Rectangle(1, 2, 3, 4));
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "[1, 2, 3, 4]" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
}
{
- value = Property::Value( AngleAxis( Dali::ANGLE_120, Vector3::XAXIS ) );
+ value = Property::Value(AngleAxis(Dali::ANGLE_120, Vector3::XAXIS));
std::ostringstream stream;
- stream << value;
- tet_printf("angle axis = %s \n", stream.str().c_str() );
- DALI_TEST_EQUALS( stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION );
+ stream << value;
+ tet_printf("angle axis = %s \n", stream.str().c_str());
+ DALI_TEST_EQUALS(stream.str(), "[ Axis: [1, 0, 0], Angle: 120 degrees ]", TEST_LOCATION);
}
{
- value = Property::Value( std::string( "Foo" ) );
+ value = Property::Value(std::string("Foo"));
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "Foo" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "Foo");
}
{
map.Insert("duration", 10);
map.Insert("color", Vector4(1.0, 0.5, 1.0, 1.0));
- value = Property::Value( map );
+ value = Property::Value(map);
std::ostringstream stream;
stream << value;
tet_printf("Checking Property::Value is %s", stream.str().c_str());
- DALI_TEST_CHECK( !stream.str().compare("Map(3) = {key:value, duration:10, color:[1, 0.5, 1, 1]}"));
+ DALI_TEST_CHECK(!stream.str().compare("Map(3) = {key:value, duration:10, color:[1, 0.5, 1, 1]}"));
}
{
Property::Array array;
array.PushBack(0);
array.PushBack(2);
array.PushBack(3);
- value = Property::Value( array );
+ value = Property::Value(array);
std::ostringstream stream;
- stream << value;
+ stream << value;
tet_printf("Checking Property::Value is %s", stream.str().c_str());
- DALI_TEST_CHECK( !stream.str().compare("Array(3) = [0, 2, 3]") );
+ DALI_TEST_CHECK(!stream.str().compare("Array(3) = [0, 2, 3]"));
}
{
- Property::Map map;
- Property::Map map2;
+ Property::Map map;
+ Property::Map map2;
Property::Array array;
map2.Insert("key", "value");
array.PushBack(Vector2(1, 0));
array.PushBack(Vector2(0, 0.5));
map.Insert("texCoords", array);
- value = Property::Value( map );
+ value = Property::Value(map);
std::ostringstream stream;
stream << value;
tet_printf("Checking Property::Value is %s", stream.str().c_str());
- DALI_TEST_CHECK( !stream.str().compare("Map(3) = {color:[1, 0.5, 1, 1], timePeriod:Map(2) = {key:value, duration:10}, texCoords:Array(4) = [[1, 0], [0, 1], [1, 0], [0, 0.5]]}"));
+ DALI_TEST_CHECK(!stream.str().compare("Map(3) = {color:[1, 0.5, 1, 1], timePeriod:Map(2) = {key:value, duration:10}, texCoords:Array(4) = [[1, 0], [0, 1], [1, 0], [0, 0.5]]}"));
}
{
- value = Property::Value( Extents( 1u, 2u, 3u, 4u ) );
+ value = Property::Value(Extents(1u, 2u, 3u, 4u));
std::ostringstream stream;
- stream << value;
- DALI_TEST_CHECK( stream.str() == "[1, 2, 3, 4]" );
+ stream << value;
+ DALI_TEST_CHECK(stream.str() == "[1, 2, 3, 4]");
}
END_TEST;
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
#include <iostream>
#include <sstream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-
using namespace Dali;
-
void utc_dali_quaternion_startup(void)
{
test_return_value = TET_UNDEF;
test_return_value = TET_PASS;
}
-
int UtcDaliQuaternionCtorDefaultP(void)
{
Quaternion q;
- DALI_TEST_EQUALS( q.AsVector().w, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().x, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().y, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().z, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q.AsVector().w, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().x, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().y, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().z, 0.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorCosSinThetaP(void)
{
- Quaternion q( 1.0f, 0.1f, 0.2f, 0.3f );
+ Quaternion q(1.0f, 0.1f, 0.2f, 0.3f);
- DALI_TEST_EQUALS( q.AsVector().w, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().x, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().y, 0.2f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().z, 0.3f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q.AsVector().w, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().x, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().y, 0.2f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().z, 0.3f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorVector4P(void)
{
- Quaternion q( Vector4( 1.0f, 0.1f, 0.2f, 0.3f ) );
+ Quaternion q(Vector4(1.0f, 0.1f, 0.2f, 0.3f));
- DALI_TEST_EQUALS( q.AsVector().x, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().y, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().z, 0.2f, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().w, 0.3f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q.AsVector().x, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().y, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().z, 0.2f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().w, 0.3f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorAxisAngleVector3P(void)
{
- Quaternion q( Dali::ANGLE_90, Vector3( 1.0f, 2.0f, 3.0f ) );
+ Quaternion q(Dali::ANGLE_90, Vector3(1.0f, 2.0f, 3.0f));
// This will be normalised:
- DALI_TEST_EQUALS( q.AsVector().w, 0.707f, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().x, 0.189f, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().y, 0.378f, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( q.AsVector().z, 0.567f, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q.AsVector().w, 0.707f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().x, 0.189f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().y, 0.378f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(q.AsVector().z, 0.567f, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorEulerAngleP(void)
{
Quaternion q1(0.924f, 0.383f, 0.0f, 0.0f);
- Vector4 r1(Radian(Degree(45)), 0.0f, 0.0f, 0.0f);
+ Vector4 r1(Radian(Degree(45)), 0.0f, 0.0f, 0.0f);
Quaternion q2(0.793f, 0.0f, 0.609f, 0.0f);
- Vector4 r2(0.0f, Radian(Degree(75)), 0.0f, 0.0f);
+ Vector4 r2(0.0f, Radian(Degree(75)), 0.0f, 0.0f);
Quaternion q3(0.383f, 0.0f, 0.0f, 0.924f);
- Vector4 r3(0.0f, 0.0f, Radian(Degree(135)), 0.0f);
+ Vector4 r3(0.0f, 0.0f, Radian(Degree(135)), 0.0f);
Quaternion q4(0.795f, 0.478f, 0.374f, 0.006f);
- Vector4 r4(Radian(Degree(71)), Radian(Degree(36)), Radian(Degree(27)), 0.0f);
+ Vector4 r4(Radian(Degree(71)), Radian(Degree(36)), Radian(Degree(27)), 0.0f);
- Quaternion q5( -0.149f, -0.697f, 0.145f, -0.686f);
- Vector4 r5(Radian(Degree(148.0)), Radian(Degree(-88.2)), Radian(Degree(8.0)), 0.0f);
+ Quaternion q5(-0.149f, -0.697f, 0.145f, -0.686f);
+ Vector4 r5(Radian(Degree(148.0)), Radian(Degree(-88.2)), Radian(Degree(8.0)), 0.0f);
DALI_TEST_EQUALS(q1.EulerAngles(), r1, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(q2.EulerAngles(), r2, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(q3.EulerAngles(), r3, 0.001, TEST_LOCATION);
- DALI_TEST_EQUALS(q4.EulerAngles(), r4, 0.01, TEST_LOCATION);
- DALI_TEST_EQUALS(q5.EulerAngles(), r5, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(q4.EulerAngles(), r4, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(q5.EulerAngles(), r5, 0.01, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorMatrixP01(void)
{
// angle: 60 deg, axis: [1,2,3]
- float Mref_raw[16] = { 0.535714f, 0.765794f, -0.355767f, 0.0f,
- -0.622936f, 0.642857f, 0.445741f, 0.0f,
- 0.570053f, -0.0171693f, 0.821429f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f};
- Matrix Mref( Mref_raw );
+ float Mref_raw[16] = {0.535714f, 0.765794f, -0.355767f, 0.0f, -0.622936f, 0.642857f, 0.445741f, 0.0f, 0.570053f, -0.0171693f, 0.821429f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+ Matrix Mref(Mref_raw);
- Quaternion q1( Radian(M_PI/3.0f), Vector3( 1.0f, 2.0f, 3.0f ) );
- Quaternion q2( Mref );
+ Quaternion q1(Radian(M_PI / 3.0f), Vector3(1.0f, 2.0f, 3.0f));
+ Quaternion q2(Mref);
- DALI_TEST_EQUALS( q1, q2, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q2, 0.001, TEST_LOCATION);
END_TEST;
}
// IDENTITY rotation
Quaternion q;
- Matrix m( q ); // Convert to matrix
+ Matrix m(q); // Convert to matrix
- Quaternion q2( m ); // and back to a quaternion
+ Quaternion q2(m); // and back to a quaternion
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( m, Matrix::IDENTITY, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(m, Matrix::IDENTITY, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorMatrixP03(void)
{
// Create an arbitrary forward vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
- Vector3 vForward( x, y, z );
+ Vector3 vForward(x, y, z);
vForward.Normalize();
// Construct an up vector from a sideways move
Vector3 vSide;
- Vector3 vUp = vForward.Cross( Vector3( vForward.x+1.0f, vForward.y, vForward.z ) );
- if( vUp.Length() > 0.01 )
+ Vector3 vUp = vForward.Cross(Vector3(vForward.x + 1.0f, vForward.y, vForward.z));
+ if(vUp.Length() > 0.01)
{
vUp.Normalize();
- vSide = vUp.Cross( vForward );
+ vSide = vUp.Cross(vForward);
vSide.Normalize();
}
else
{
- vSide = vForward.Cross( Vector3( vForward.x, vForward.y+1.0f, vForward.z ) );
+ vSide = vForward.Cross(Vector3(vForward.x, vForward.y + 1.0f, vForward.z));
vSide.Normalize();
- vUp = vForward.Cross( vSide );
+ vUp = vForward.Cross(vSide);
vUp.Normalize();
}
// Generate a matrix, and then a quaternion from it
- Matrix rotMatrix( Matrix::IDENTITY );
- rotMatrix.SetXAxis( vSide );
- rotMatrix.SetYAxis( vUp );
- rotMatrix.SetZAxis( vForward );
- Quaternion q( rotMatrix );
+ Matrix rotMatrix(Matrix::IDENTITY);
+ rotMatrix.SetXAxis(vSide);
+ rotMatrix.SetYAxis(vUp);
+ rotMatrix.SetZAxis(vForward);
+ Quaternion q(rotMatrix);
// Generate a matrix from the quaternion, check they are the same
- Matrix resultMatrix( q );
- DALI_TEST_EQUALS( resultMatrix, rotMatrix, 0.001f, TEST_LOCATION );
+ Matrix resultMatrix(q);
+ DALI_TEST_EQUALS(resultMatrix, rotMatrix, 0.001f, TEST_LOCATION);
// Rotate an arbitrary vector by both quaternion and rotation matrix,
// check the result is the same
- Vector4 aVector( -2.983f, -3.213f, 8.2239f, 1.0f );
- Vector3 aVectorRotatedByQ = q.Rotate( Vector3( aVector ) );
- Vector4 aVectorRotatedByR = rotMatrix*aVector;
- DALI_TEST_EQUALS( aVectorRotatedByQ, Vector3( aVectorRotatedByR ), 0.001f, TEST_LOCATION );
+ Vector4 aVector(-2.983f, -3.213f, 8.2239f, 1.0f);
+ Vector3 aVectorRotatedByQ = q.Rotate(Vector3(aVector));
+ Vector4 aVectorRotatedByR = rotMatrix * aVector;
+ DALI_TEST_EQUALS(aVectorRotatedByQ, Vector3(aVectorRotatedByR), 0.001f, TEST_LOCATION);
}
}
}
int UtcDaliQuaternionCopyConstructor(void)
{
- Quaternion q0( 1.0f, 0.1f, 0.2f, 0.3f );
- Quaternion q1( q0 );
- DALI_TEST_EQUALS( q1.AsVector().w, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().x, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().y, 0.2f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().z, 0.3f, TEST_LOCATION );
+ Quaternion q0(1.0f, 0.1f, 0.2f, 0.3f);
+ Quaternion q1(q0);
+ DALI_TEST_EQUALS(q1.AsVector().w, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().x, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().y, 0.2f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().z, 0.3f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionMoveConstructor(void)
{
- Quaternion q0( 1.0f, 0.1f, 0.2f, 0.3f );
- Quaternion q1 = std::move( q0 );
- DALI_TEST_EQUALS( q1.AsVector().w, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().x, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().y, 0.2f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().z, 0.3f, TEST_LOCATION );
+ Quaternion q0(1.0f, 0.1f, 0.2f, 0.3f);
+ Quaternion q1 = std::move(q0);
+ DALI_TEST_EQUALS(q1.AsVector().w, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().x, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().y, 0.2f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().z, 0.3f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCopyAssignment(void)
{
- Quaternion q0( 1.0f, 0.1f, 0.2f, 0.3f );
+ Quaternion q0(1.0f, 0.1f, 0.2f, 0.3f);
Quaternion q1;
q1 = q0;
- DALI_TEST_EQUALS( q1.AsVector().w, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().x, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().y, 0.2f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().z, 0.3f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1.AsVector().w, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().x, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().y, 0.2f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().z, 0.3f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionMoveAssignment(void)
{
- Quaternion q0( 1.0f, 0.1f, 0.2f, 0.3f );
+ Quaternion q0(1.0f, 0.1f, 0.2f, 0.3f);
Quaternion q1;
- q1 = std::move( q0 );
- DALI_TEST_EQUALS( q1.AsVector().w, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().x, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().y, 0.2f, TEST_LOCATION );
- DALI_TEST_EQUALS( q1.AsVector().z, 0.3f, TEST_LOCATION );
+ q1 = std::move(q0);
+ DALI_TEST_EQUALS(q1.AsVector().w, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().x, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().y, 0.2f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q1.AsVector().z, 0.3f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorAxesP01(void)
{
// angle: 60 deg, axis: [1,2,3]
- float Mref_raw[16] = { 0.535714f, 0.765794f, -0.355767f, 0.0f,
- -0.622936f, 0.642857f, 0.445741f, 0.0f,
- 0.570053f, -0.0171693f, 0.821429f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f};
- Matrix Mref( Mref_raw );
+ float Mref_raw[16] = {0.535714f, 0.765794f, -0.355767f, 0.0f, -0.622936f, 0.642857f, 0.445741f, 0.0f, 0.570053f, -0.0171693f, 0.821429f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+ Matrix Mref(Mref_raw);
- Quaternion q1( Radian(M_PI/3.0f), Vector3( 1.0f, 2.0f, 3.0f ) );
- Quaternion q2( Mref.GetXAxis(), Mref.GetYAxis(), Mref.GetZAxis() );
+ Quaternion q1(Radian(M_PI / 3.0f), Vector3(1.0f, 2.0f, 3.0f));
+ Quaternion q2(Mref.GetXAxis(), Mref.GetYAxis(), Mref.GetZAxis());
- DALI_TEST_EQUALS( q1, q2, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q2, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionCtorAxesP02(void)
{
- Vector3 xAxis( Vector3::XAXIS );
- Vector3 yAxis( Vector3::YAXIS );
- Vector3 zAxis( Vector3::ZAXIS );
+ Vector3 xAxis(Vector3::XAXIS);
+ Vector3 yAxis(Vector3::YAXIS);
+ Vector3 zAxis(Vector3::ZAXIS);
- Quaternion q1( xAxis, yAxis, zAxis );
+ Quaternion q1(xAxis, yAxis, zAxis);
- DALI_TEST_EQUALS( q1, Quaternion::IDENTITY, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, Quaternion::IDENTITY, TEST_LOCATION);
- xAxis = Vector3( 1.0f, 1.0f, 0.0f );
+ xAxis = Vector3(1.0f, 1.0f, 0.0f);
xAxis.Normalize();
- yAxis = Vector3( -1.0f, 1.0f, 0.0f ); // 45 degrees anticlockwise ( +ve ) around z
+ yAxis = Vector3(-1.0f, 1.0f, 0.0f); // 45 degrees anticlockwise ( +ve ) around z
yAxis.Normalize();
- zAxis = xAxis.Cross( yAxis );
+ zAxis = xAxis.Cross(yAxis);
zAxis.Normalize();
- Quaternion q2( xAxis, yAxis, zAxis );
+ Quaternion q2(xAxis, yAxis, zAxis);
- DALI_TEST_EQUALS( q2, Quaternion( Radian( Degree( 45 ) ), Vector3::ZAXIS ), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, Quaternion(Radian(Degree(45)), Vector3::ZAXIS), 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionCtorAxesP03(void)
{
// Create an arbitrary forward vector
- for( float x=-1.0f; x<=1.0f; x+=0.1f )
+ for(float x = -1.0f; x <= 1.0f; x += 0.1f)
{
- for( float y=-1.0f; y<1.0f; y+=0.1f )
+ for(float y = -1.0f; y < 1.0f; y += 0.1f)
{
- for( float z=-1.0f; z<1.0f; z+=0.1f )
+ for(float z = -1.0f; z < 1.0f; z += 0.1f)
{
- Vector3 vForward( x, y, z );
+ Vector3 vForward(x, y, z);
vForward.Normalize();
// Construct an up vector from a sideways move
Vector3 vSide;
- Vector3 vUp = vForward.Cross( Vector3( vForward.x+1.0f, vForward.y, vForward.z ) );
- if( vUp.Length() > 0.01 )
+ Vector3 vUp = vForward.Cross(Vector3(vForward.x + 1.0f, vForward.y, vForward.z));
+ if(vUp.Length() > 0.01)
{
vUp.Normalize();
- vSide = vUp.Cross( vForward );
+ vSide = vUp.Cross(vForward);
vSide.Normalize();
}
else
{
- vSide = vForward.Cross( Vector3( vForward.x, vForward.y+1.0f, vForward.z ) );
+ vSide = vForward.Cross(Vector3(vForward.x, vForward.y + 1.0f, vForward.z));
vSide.Normalize();
- vUp = vForward.Cross( vSide );
+ vUp = vForward.Cross(vSide);
vUp.Normalize();
}
// Generate a quaternion
- Quaternion q( vSide, vUp, vForward );
+ Quaternion q(vSide, vUp, vForward);
Matrix rotMatrix;
- rotMatrix.SetXAxis( vSide );
- rotMatrix.SetYAxis( vUp );
- rotMatrix.SetZAxis( vForward );
+ rotMatrix.SetXAxis(vSide);
+ rotMatrix.SetYAxis(vUp);
+ rotMatrix.SetZAxis(vForward);
// Generate a matrix from the quaternion, check they are the same
- Matrix m( q );
- DALI_TEST_EQUALS( m.GetXAxis(), vSide, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( m.GetYAxis(), vUp, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( m.GetZAxis(), vForward, 0.001f, TEST_LOCATION );
+ Matrix m(q);
+ DALI_TEST_EQUALS(m.GetXAxis(), vSide, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(m.GetYAxis(), vUp, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(m.GetZAxis(), vForward, 0.001f, TEST_LOCATION);
// Rotate an arbitrary vector by both quaternion and rotation matrix,
// check the result is the same
- Vector4 aVector( 2.043f, 12.8f, -3.872f, 1.0f );
- Vector3 aVectorRotatedByQ = q.Rotate( Vector3( aVector ) );
- Vector4 aVectorRotatedByR = rotMatrix*aVector;
- DALI_TEST_EQUALS( aVectorRotatedByQ, Vector3( aVectorRotatedByR ), 0.001f, TEST_LOCATION );
+ Vector4 aVector(2.043f, 12.8f, -3.872f, 1.0f);
+ Vector3 aVectorRotatedByQ = q.Rotate(Vector3(aVector));
+ Vector4 aVectorRotatedByR = rotMatrix * aVector;
+ DALI_TEST_EQUALS(aVectorRotatedByQ, Vector3(aVectorRotatedByR), 0.001f, TEST_LOCATION);
}
}
}
int UtcDaliQuaternionCtorTwoVectorsP(void)
{
- Vector3 v0( 1.0f, 2.0f, 3.0f );
- Vector3 v1( -2.0f, 10.0f, -1.0f );
+ Vector3 v0(1.0f, 2.0f, 3.0f);
+ Vector3 v1(-2.0f, 10.0f, -1.0f);
v0.Normalize();
v1.Normalize();
- Quaternion q( v0, v1 );
+ Quaternion q(v0, v1);
- DALI_TEST_EQUALS( q*v0, v1, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q * v0, v1, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionAsVectorP(void)
{
- Vector4 v( 1.0f, 0.1f, 0.2f, 0.3f );
- Quaternion q( v );
+ Vector4 v(1.0f, 0.1f, 0.2f, 0.3f);
+ Quaternion q(v);
- DALI_TEST_EQUALS( v, q.AsVector(), TEST_LOCATION );
+ DALI_TEST_EQUALS(v, q.AsVector(), TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionToAxisAngleVector3P(void)
{
- Quaternion q( 0.932f, 1.1f, 3.4f, 2.7f );
- Radian angle;
- Vector3 axis;
- bool converted = q.ToAxisAngle( axis, angle );
- DALI_TEST_EQUALS( converted, true, TEST_LOCATION );
- DALI_TEST_EQUALS( angle.radian, 0.74f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.x, 3.03f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.y, 9.38f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.z, 7.45f, 0.01f, TEST_LOCATION );
+ Quaternion q(0.932f, 1.1f, 3.4f, 2.7f);
+ Radian angle;
+ Vector3 axis;
+ bool converted = q.ToAxisAngle(axis, angle);
+ DALI_TEST_EQUALS(converted, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(angle.radian, 0.74f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.x, 3.03f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.y, 9.38f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.z, 7.45f, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionToAxisAngleVector3N(void)
{
- Quaternion q( 1, 2, 3, 4 );
- Radian angle;
- Vector3 axis;
- bool converted = q.ToAxisAngle( axis, angle );
- DALI_TEST_EQUALS( converted, false, TEST_LOCATION );
- DALI_TEST_EQUALS( angle.radian, 0.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.x, 0.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.y, 0.0f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.z, 0.0f, 0.01f, TEST_LOCATION );
+ Quaternion q(1, 2, 3, 4);
+ Radian angle;
+ Vector3 axis;
+ bool converted = q.ToAxisAngle(axis, angle);
+ DALI_TEST_EQUALS(converted, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(angle.radian, 0.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.x, 0.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.y, 0.0f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.z, 0.0f, 0.01f, TEST_LOCATION);
END_TEST;
}
{
// Test from euler angles
Quaternion e1;
- e1.SetEuler( Dali::ANGLE_45, Dali::ANGLE_0, Dali::ANGLE_0 );
- Vector4 r1( 0.383f, 0.0f, 0.0f, 0.924f );
+ e1.SetEuler(Dali::ANGLE_45, Dali::ANGLE_0, Dali::ANGLE_0);
+ Vector4 r1(0.383f, 0.0f, 0.0f, 0.924f);
Quaternion e2;
- e2.SetEuler( Dali::ANGLE_0, Radian( Degree( 75 ) ), Dali::ANGLE_0 );
- Vector4 r2( 0.0f, 0.609f, 0.0f, 0.793f );
+ e2.SetEuler(Dali::ANGLE_0, Radian(Degree(75)), Dali::ANGLE_0);
+ Vector4 r2(0.0f, 0.609f, 0.0f, 0.793f);
Quaternion e3;
- e3.SetEuler( Dali::ANGLE_0, Dali::ANGLE_0, Radian( Degree( 135 ) ) );
- Vector4 r3( 0.0f, 0.0f, 0.924f, 0.383f );
+ e3.SetEuler(Dali::ANGLE_0, Dali::ANGLE_0, Radian(Degree(135)));
+ Vector4 r3(0.0f, 0.0f, 0.924f, 0.383f);
Quaternion e4;
- e4.SetEuler( Radian( Degree( 71 ) ), Radian( Degree( 36 ) ), Radian( Degree( 27 ) ) );
- Vector4 r4( 0.478f, 0.374f, 0.006f, 0.795f );
+ e4.SetEuler(Radian(Degree(71)), Radian(Degree(36)), Radian(Degree(27)));
+ Vector4 r4(0.478f, 0.374f, 0.006f, 0.795f);
Quaternion e5;
- e5.SetEuler( Radian( Degree( -31 ) ), Radian( Degree( -91 ) ), Radian( Degree( -173 ) ) );
- Vector4 r5( -0.697f, 0.145f, -0.686f, -0.149f );
+ e5.SetEuler(Radian(Degree(-31)), Radian(Degree(-91)), Radian(Degree(-173)));
+ Vector4 r5(-0.697f, 0.145f, -0.686f, -0.149f);
- DALI_TEST_EQUALS( e1.AsVector(), r1, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( e2.AsVector(), r2, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( e3.AsVector(), r3, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( e4.AsVector(), r4, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( e5.AsVector(), r5, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(e1.AsVector(), r1, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(e2.AsVector(), r2, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(e3.AsVector(), r3, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(e4.AsVector(), r4, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(e5.AsVector(), r5, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionEulerAnglesP(void)
{
- Quaternion q1( 0.924f, 0.383f, 0.0f, 0.0f );
- Vector4 r1( Radian( Degree( 45 ) ), 0.0f, 0.0f, 0.0f );
+ Quaternion q1(0.924f, 0.383f, 0.0f, 0.0f);
+ Vector4 r1(Radian(Degree(45)), 0.0f, 0.0f, 0.0f);
- Quaternion q2( 0.793f, 0.0f, 0.609f, 0.0f );
- Vector4 r2( 0.0f, Radian( Degree( 75 ) ), 0.0f, 0.0f );
+ Quaternion q2(0.793f, 0.0f, 0.609f, 0.0f);
+ Vector4 r2(0.0f, Radian(Degree(75)), 0.0f, 0.0f);
- Quaternion q3( 0.383f, 0.0f, 0.0f, 0.924f );
- Vector4 r3( 0.0f, 0.0f, Radian( Degree( 135 ) ), 0.0f );
+ Quaternion q3(0.383f, 0.0f, 0.0f, 0.924f);
+ Vector4 r3(0.0f, 0.0f, Radian(Degree(135)), 0.0f);
- Quaternion q4( 0.795f, 0.478f, 0.374f, 0.006f );
- Vector4 r4( Radian( Degree( 71 ) ), Radian( Degree( 36 ) ), Radian( Degree( 27 ) ), 0.0f );
+ Quaternion q4(0.795f, 0.478f, 0.374f, 0.006f);
+ Vector4 r4(Radian(Degree(71)), Radian(Degree(36)), Radian(Degree(27)), 0.0f);
- Quaternion q5( -0.149f, -0.697f, 0.145f, -0.686f );
- Vector4 r5( Radian( Degree( 148.0 ) ), Radian( Degree( -88.2 ) ), Radian( Degree( 8.0 ) ), 0.0f );
+ Quaternion q5(-0.149f, -0.697f, 0.145f, -0.686f);
+ Vector4 r5(Radian(Degree(148.0)), Radian(Degree(-88.2)), Radian(Degree(8.0)), 0.0f);
- DALI_TEST_EQUALS( q1.EulerAngles(), r1, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( q2.EulerAngles(), r2, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( q3.EulerAngles(), r3, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( q4.EulerAngles(), r4, 0.01, TEST_LOCATION );
- DALI_TEST_EQUALS( q5.EulerAngles(), r5, 0.01, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1.EulerAngles(), r1, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(q2.EulerAngles(), r2, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(q3.EulerAngles(), r3, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(q4.EulerAngles(), r4, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(q5.EulerAngles(), r5, 0.01, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionToMatrixP01(void)
{
- Quaternion q( Radian( 0.69813 ), Vector3( 1.0f, 0.0f, 0.0f ) ); // 40 degree rotation around X axis
+ Quaternion q(Radian(0.69813), Vector3(1.0f, 0.0f, 0.0f)); // 40 degree rotation around X axis
// Result calculated using a different maths library ( with appropriate row/col ordering )
- float els[] = { 1.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 0.766f, 0.643f, 0.0f,
- 0.0f, -0.643f, 0.766f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f };
- Matrix mRes( els );
- Matrix m( q );
+ float els[] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.766f, 0.643f, 0.0f, 0.0f, -0.643f, 0.766f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
+ Matrix mRes(els);
+ Matrix m(q);
- DALI_TEST_EQUALS( m, mRes, 0.01, TEST_LOCATION );
+ DALI_TEST_EQUALS(m, mRes, 0.01, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionToMatrixP02(void)
{
// rotation around arbitrary axis
- Quaternion q2( Radian( -1.23918f ), Vector3( 7.0f, -13.0f, 11.0f ) );
+ Quaternion q2(Radian(-1.23918f), Vector3(7.0f, -13.0f, 11.0f));
- float els[] = { 0.423f, -0.746f, -0.514f, 0.00f,
- 0.384f, 0.662f, -0.644f, 0.00f,
- 0.821f, 0.075f, 0.566f, 0.00f,
- 0.000f, 0.000f, 0.000f, 1.00f };
- Matrix mRes2( els );
+ float els[] = {0.423f, -0.746f, -0.514f, 0.00f, 0.384f, 0.662f, -0.644f, 0.00f, 0.821f, 0.075f, 0.566f, 0.00f, 0.000f, 0.000f, 0.000f, 1.00f};
+ Matrix mRes2(els);
- Matrix m2( q2 );
+ Matrix m2(q2);
- DALI_TEST_EQUALS( m2, mRes2, 0.01, TEST_LOCATION );
+ DALI_TEST_EQUALS(m2, mRes2, 0.01, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionOperatorAdditionP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion q2( 0.0f, 0.609f, 0.0f, 0.793f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion q2(0.0f, 0.609f, 0.0f, 0.793f);
- Quaternion r1( 0.383f, 0.609f, 0.0f, 1.717f );
+ Quaternion r1(0.383f, 0.609f, 0.0f, 1.717f);
- DALI_TEST_EQUALS( q1+q2, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1 + q2, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorSubtractionP(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- Quaternion q2( 0.383f, 0.690f, 0.234f, 1.917f );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ Quaternion q2(0.383f, 0.690f, 0.234f, 1.917f);
- Quaternion r1( 0.0f, 0.240f, 0.111f, 0.993f );
+ Quaternion r1(0.0f, 0.240f, 0.111f, 0.993f);
- DALI_TEST_EQUALS( q2-q1, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2 - q1, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionConjugateP(void)
{
- float s1 = 0.784f; Vector3 v1( 0.045f, 0.443f, 0.432f );
- float s2 = 0.697f; Vector3 v2( 0.612, 0.344, -0.144 );
+ float s1 = 0.784f;
+ Vector3 v1(0.045f, 0.443f, 0.432f);
+ float s2 = 0.697f;
+ Vector3 v2(0.612, 0.344, -0.144);
- Quaternion q1( s1, v1.x, v1.y, v1.z );
- Quaternion q2( s2, v2.x, v2.y, v2.z );
+ Quaternion q1(s1, v1.x, v1.y, v1.z);
+ Quaternion q2(s2, v2.x, v2.y, v2.z);
q1.Conjugate();
q2.Conjugate();
- Quaternion r1( s1, -v1.x, -v1.y, -v1.z );
- Quaternion r2( s2, -v2.x, -v2.y, -v2.z );
+ Quaternion r1(s1, -v1.x, -v1.y, -v1.z);
+ Quaternion r2(s2, -v2.x, -v2.y, -v2.z);
- DALI_TEST_EQUALS( q1, r1, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( q2, r2, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, r1, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(q2, r2, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplicationQuaternionP(void)
{
- float s1=0.784f; Vector3 v1( 0.045f, 0.443f, 0.432f );
- float s2=0.697f; Vector3 v2( 0.612, 0.344, -0.144 );
+ float s1 = 0.784f;
+ Vector3 v1(0.045f, 0.443f, 0.432f);
+ float s2 = 0.697f;
+ Vector3 v2(0.612, 0.344, -0.144);
- Quaternion q1( s1, v1.x, v1.y, v1.z );
- Quaternion q2( s2, v2.x, v2.y, v2.z );
+ Quaternion q1(s1, v1.x, v1.y, v1.z);
+ Quaternion q2(s2, v2.x, v2.y, v2.z);
- Vector3 vp = v1.Cross( v2 ) + v2*s1 + v1*s2;
- Quaternion r1( s1*s2-v1.Dot( v2 ), vp.x, vp.y, vp.z );
+ Vector3 vp = v1.Cross(v2) + v2 * s1 + v1 * s2;
+ Quaternion r1(s1 * s2 - v1.Dot(v2), vp.x, vp.y, vp.z);
- DALI_TEST_EQUALS( q1*q2, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1 * q2, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplicationVector3P(void)
{
// Rotation of vector p = ( x,y,z ) by Quaternion q == q [0,p] q^-1
- Vector3 v( 2, 3, 4 );
- Quaternion q( Radian( Degree( 72 ) ), Vector3::ZAXIS );
+ Vector3 v(2, 3, 4);
+ Quaternion q(Radian(Degree(72)), Vector3::ZAXIS);
Quaternion qI = q;
qI.Invert();
- Quaternion qv( 0.0f, v.x, v.y, v.z );
- Quaternion r1 = ( q * qv ) * qI;
+ Quaternion qv(0.0f, v.x, v.y, v.z);
+ Quaternion r1 = (q * qv) * qI;
Vector3 r2 = q * v;
- DALI_TEST_EQUALS( r1.mVector.x, r2.x, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.y, r2.y, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.z, r2.z, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(r1.mVector.x, r2.x, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.y, r2.y, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.z, r2.z, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplicationFloatP01(void)
{
// Rotation of vector p = ( x,y,z ) by Quaternion q == q [0,p] q^-1
- Quaternion q( Vector4( 0.1f, 0.2f, 0.3f, 1.0f ) );
+ Quaternion q(Vector4(0.1f, 0.2f, 0.3f, 1.0f));
Quaternion q2 = q * 2.f;
- Vector4 v2( 0.2f, 0.4f, 0.6f, 2.0f );
+ Vector4 v2(0.2f, 0.4f, 0.6f, 2.0f);
- DALI_TEST_EQUALS( q2.AsVector(), v2, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2.AsVector(), v2, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplicationFloatP02(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion r1( 2.0f* 0.383f, 0.0f, 0.0f, 2.0f * 0.924f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion r1(2.0f * 0.383f, 0.0f, 0.0f, 2.0f * 0.924f);
- DALI_TEST_EQUALS( q1 * 2.0f, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1 * 2.0f, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplicationFloatP03(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion r1( 0.5f* 0.383f, 0.0f, 0.0f, 0.5f * 0.924f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion r1(0.5f * 0.383f, 0.0f, 0.0f, 0.5f * 0.924f);
- DALI_TEST_EQUALS( q1 / 2.0f, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1 / 2.0f, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorDivisionQuaternionP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion q2( 0.0f, 0.609f, 0.0f, 0.793f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion q2(0.0f, 0.609f, 0.0f, 0.793f);
// q1 / q2 = q1 * q2^-1
// q2^-1 = q2* / ||q2||^2
Quaternion r1 = q2;
r1.Conjugate();
- r1 *= 1.0f/q2.LengthSquared();
+ r1 *= 1.0f / q2.LengthSquared();
Quaternion r2 = q1 * r1;
- DALI_TEST_EQUALS( q1 / q2, r2, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1 / q2, r2, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorDivisionFloatP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion r1( 2.0f* 0.383f, 0.0f, 0.0f, 2.0f * 0.924f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion r1(2.0f * 0.383f, 0.0f, 0.0f, 2.0f * 0.924f);
- DALI_TEST_EQUALS( q1, r1/2.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, r1 / 2.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorDivideAssignedFloatP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion r1( 2.0f* 0.383f, 0.0f, 0.0f, 2.0f * 0.924f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion r1(2.0f * 0.383f, 0.0f, 0.0f, 2.0f * 0.924f);
r1 /= 2.0f;
- DALI_TEST_EQUALS( q1, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorNegationP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion r1( -0.383f, -0.0f, -0.0f, -0.924f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion r1(-0.383f, -0.0f, -0.0f, -0.924f);
- DALI_TEST_EQUALS( -q1, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(-q1, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorAddAssignP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
- Quaternion q2( 0.0f, 0.609f, 0.0f, 0.793f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
+ Quaternion q2(0.0f, 0.609f, 0.0f, 0.793f);
- Quaternion r1( 0.383f, 0.609f, 0.0f, 1.717f );
+ Quaternion r1(0.383f, 0.609f, 0.0f, 1.717f);
q1 += q2;
- DALI_TEST_EQUALS( q1, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorSubtractAssignP(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- Quaternion q2( 0.383f, 0.690f, 0.234f, 1.917f );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ Quaternion q2(0.383f, 0.690f, 0.234f, 1.917f);
- Quaternion r1( 0.0f, 0.240f, 0.111f, 0.993f );
+ Quaternion r1(0.0f, 0.240f, 0.111f, 0.993f);
q2 -= q1;
- DALI_TEST_EQUALS( q2, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplyAssignQuaternionP(void)
{
- float s1=0.784f; Vector3 v1( 0.045f, 0.443f, 0.432f );
- float s2=0.697f; Vector3 v2( 0.612, 0.344, -0.144 );
+ float s1 = 0.784f;
+ Vector3 v1(0.045f, 0.443f, 0.432f);
+ float s2 = 0.697f;
+ Vector3 v2(0.612, 0.344, -0.144);
- Quaternion q1( s1, v1.x, v1.y, v1.z );
- Quaternion q2( s2, v2.x, v2.y, v2.z );
+ Quaternion q1(s1, v1.x, v1.y, v1.z);
+ Quaternion q2(s2, v2.x, v2.y, v2.z);
Quaternion r3 = q2 * q1;
q2 *= q1;
- DALI_TEST_EQUALS( q2, r3, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, r3, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplyAssignFloatP01(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- float scale = 2.5f;
- Quaternion r1( scale*0.383f, scale*0.450f, scale*0.123f, scale*0.924f );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ float scale = 2.5f;
+ Quaternion r1(scale * 0.383f, scale * 0.450f, scale * 0.123f, scale * 0.924f);
q1 *= scale;
- DALI_TEST_EQUALS( q1, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorMultiplyAssignFloatP02(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- float scale = 2.5f;
- Quaternion r1( 0.383f/scale, 0.450f/scale, 0.123f/scale, 0.924f/scale );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ float scale = 2.5f;
+ Quaternion r1(0.383f / scale, 0.450f / scale, 0.123f / scale, 0.924f / scale);
q1 /= scale;
- DALI_TEST_EQUALS( q1, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionOperatorEqualityP(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- Quaternion q2( 0.383f, 0.450f, 0.123f, 0.924f );
- Quaternion q3( 0.383f, 0.450f, 0.123f, 0.800f );
- Quaternion q4( 0.383f, 0.450f, 0.100f, 0.800f );
- Quaternion q5( 0.383f, 0.100f, 0.100f, 0.800f );
- Quaternion q6( 0.100f, 0.100f, 0.100f, 0.800f );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ Quaternion q2(0.383f, 0.450f, 0.123f, 0.924f);
+ Quaternion q3(0.383f, 0.450f, 0.123f, 0.800f);
+ Quaternion q4(0.383f, 0.450f, 0.100f, 0.800f);
+ Quaternion q5(0.383f, 0.100f, 0.100f, 0.800f);
+ Quaternion q6(0.100f, 0.100f, 0.100f, 0.800f);
- Quaternion q7( -0.383f, -0.450f, -0.123f, -0.924f );
- Quaternion q8( -0.383f, -0.450f, -0.123f, 0.924f );
- Quaternion q9( -0.383f, -0.450f, 0.123f, 0.924f );
- Quaternion q10( -0.383f, 0.450f, 0.123f, 0.924f );
+ Quaternion q7(-0.383f, -0.450f, -0.123f, -0.924f);
+ Quaternion q8(-0.383f, -0.450f, -0.123f, 0.924f);
+ Quaternion q9(-0.383f, -0.450f, 0.123f, 0.924f);
+ Quaternion q10(-0.383f, 0.450f, 0.123f, 0.924f);
- DALI_TEST_CHECK( q1 == q2 );
- DALI_TEST_CHECK( !( q1 == q3 ) );
- DALI_TEST_CHECK( !( q1 == q4 ) );
- DALI_TEST_CHECK( !( q1 == q5 ) );
- DALI_TEST_CHECK( !( q1 == q6 ) );
- DALI_TEST_CHECK( ( q1 == q7 ) );
- DALI_TEST_CHECK( !( q1 == q8 ) );
- DALI_TEST_CHECK( !( q1 == q9 ) );
- DALI_TEST_CHECK( !( q1 == q10 ) );
+ DALI_TEST_CHECK(q1 == q2);
+ DALI_TEST_CHECK(!(q1 == q3));
+ DALI_TEST_CHECK(!(q1 == q4));
+ DALI_TEST_CHECK(!(q1 == q5));
+ DALI_TEST_CHECK(!(q1 == q6));
+ DALI_TEST_CHECK((q1 == q7));
+ DALI_TEST_CHECK(!(q1 == q8));
+ DALI_TEST_CHECK(!(q1 == q9));
+ DALI_TEST_CHECK(!(q1 == q10));
END_TEST;
}
int UtcDaliQuaternionOperatorInequalityP(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- Quaternion q2( 0.383f, 0.450f, 0.123f, 0.924f );
- Quaternion q3( -0.383f, -0.0f, -0.0f, -0.924f );
- DALI_TEST_CHECK( !( q1 != q2 ) );
- DALI_TEST_CHECK( q1 != q3 );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ Quaternion q2(0.383f, 0.450f, 0.123f, 0.924f);
+ Quaternion q3(-0.383f, -0.0f, -0.0f, -0.924f);
+ DALI_TEST_CHECK(!(q1 != q2));
+ DALI_TEST_CHECK(q1 != q3);
END_TEST;
}
int UtcDaliQuaternionLengthP(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- float length = sqrtf( 0.383f*0.383f + 0.450f*0.450f + 0.123f*0.123f + 0.924f*0.924f );
- DALI_TEST_EQUALS( q1.Length(), length, 0.001f, TEST_LOCATION );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ float length = sqrtf(0.383f * 0.383f + 0.450f * 0.450f + 0.123f * 0.123f + 0.924f * 0.924f);
+ DALI_TEST_EQUALS(q1.Length(), length, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionLengthSquaredP(void)
{
- Quaternion q1( 0.383f, 0.450f, 0.123f, 0.924f );
- float lengthSquared = 0.383f*0.383f + 0.450f*0.450f + 0.123f*0.123f + 0.924f*0.924f;
- DALI_TEST_EQUALS( q1.LengthSquared(), lengthSquared, 0.01f, TEST_LOCATION );
+ Quaternion q1(0.383f, 0.450f, 0.123f, 0.924f);
+ float lengthSquared = 0.383f * 0.383f + 0.450f * 0.450f + 0.123f * 0.123f + 0.924f * 0.924f;
+ DALI_TEST_EQUALS(q1.LengthSquared(), lengthSquared, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionNormalizeP(void)
{
- Quaternion q1( 0.118f, 0.692f, -0.127f, 0.701f );
+ Quaternion q1(0.118f, 0.692f, -0.127f, 0.701f);
Quaternion q2 = q1;
q2 *= 5.0f;
q2.Normalize();
- DALI_TEST_EQUALS( q1, q2, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q2, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionNormalizedP(void)
{
- Quaternion q1( 0.118f, 0.692f, -0.127f, 0.701f );
+ Quaternion q1(0.118f, 0.692f, -0.127f, 0.701f);
Quaternion q2 = q1;
q2 *= 5.0f;
- DALI_TEST_EQUALS( q1, q2.Normalized(), 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q2.Normalized(), 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionIsIdentityP(void)
{
- Quaternion q( 1.0f, 0.0f, 0.0f, 0.0f );
- DALI_TEST_EQUALS( q.IsIdentity(), true, TEST_LOCATION );
+ Quaternion q(1.0f, 0.0f, 0.0f, 0.0f);
+ DALI_TEST_EQUALS(q.IsIdentity(), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionIsIdentityN(void)
{
- Quaternion q( 1.0f, 0.1f, 0.0f, 0.0f );
- DALI_TEST_EQUALS( q.IsIdentity(), false, TEST_LOCATION );
+ Quaternion q(1.0f, 0.1f, 0.0f, 0.0f);
+ DALI_TEST_EQUALS(q.IsIdentity(), false, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionInvertP(void)
{
- Quaternion q1( 0.383f, 0.0f, 0.0f, 0.924f );
+ Quaternion q1(0.383f, 0.0f, 0.0f, 0.924f);
// q1^-1 = q1* / ||q1||^2
// = Conjugate of q1 / Square of Norm of q1
Quaternion r1 = q1;
r1.Conjugate();
- r1 *= 1.0f/q1.LengthSquared();
+ r1 *= 1.0f / q1.LengthSquared();
Quaternion q2 = q1;
q2.Invert();
- DALI_TEST_EQUALS( q2, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionDotP(void)
{
// q.q' = s*s' + v dot v'
- float s1 = 0.784f; Vector3 v1( 0.045f, 0.443f, 0.432f );
- float s2 = 0.697f; Vector3 v2( 0.612, 0.344, -0.144 );
+ float s1 = 0.784f;
+ Vector3 v1(0.045f, 0.443f, 0.432f);
+ float s2 = 0.697f;
+ Vector3 v2(0.612, 0.344, -0.144);
- Quaternion q1( s1, v1.x, v1.y, v1.z );
- Quaternion q2( s2, v2.x, v2.y, v2.z );
+ Quaternion q1(s1, v1.x, v1.y, v1.z);
+ Quaternion q2(s2, v2.x, v2.y, v2.z);
- float r1 = s1*s2 + v1.Dot( v2 );
+ float r1 = s1 * s2 + v1.Dot(v2);
- DALI_TEST_EQUALS( Quaternion::Dot( q1, q2 ), r1, TEST_LOCATION );
+ DALI_TEST_EQUALS(Quaternion::Dot(q1, q2), r1, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionRotateVector3P(void)
{
// Rotation of vector p = ( x,y,z ) by Quaternion q == q [0,p] q^-1
- Vector3 v( 2, 3, 4 );
- Quaternion q( Radian( Degree( 72 ) ), Vector3::ZAXIS );
+ Vector3 v(2, 3, 4);
+ Quaternion q(Radian(Degree(72)), Vector3::ZAXIS);
Quaternion qI = q;
qI.Invert();
- Quaternion qv( 0.0f, v.x, v.y, v.z );
+ Quaternion qv(0.0f, v.x, v.y, v.z);
Quaternion r1 = q * qv * qI;
- Vector3 r2 = q.Rotate( v );
+ Vector3 r2 = q.Rotate(v);
- DALI_TEST_EQUALS( r1.mVector.x, r2.x, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.y, r2.y, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.z, r2.z, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(r1.mVector.x, r2.x, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.y, r2.y, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.z, r2.z, 0.001f, TEST_LOCATION);
- DALI_TEST_EQUALS( q.Rotate( v ), q*v, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q.Rotate(v), q * v, 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionRotateVector4P(void)
{
// Rotation of vector p = ( x,y,z ) by Quaternion q == q [0,p] q^-1
- Vector4 v( 2, 3, 4, 5 );
- Quaternion q( Radian( Degree( 72 ) ), Vector3::ZAXIS );
+ Vector4 v(2, 3, 4, 5);
+ Quaternion q(Radian(Degree(72)), Vector3::ZAXIS);
Quaternion qI = q;
qI.Invert();
- Quaternion qv( 0.0f, v.x, v.y, v.z );
+ Quaternion qv(0.0f, v.x, v.y, v.z);
Quaternion r1 = q * qv * qI;
- Vector4 r2 = q.Rotate( v );
+ Vector4 r2 = q.Rotate(v);
- DALI_TEST_EQUALS( r1.mVector.x, r2.x, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.y, r2.y, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.z, r2.z, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( r1.mVector.w, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(r1.mVector.x, r2.x, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.y, r2.y, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.z, r2.z, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(r1.mVector.w, 0.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionExpP01(void)
{
- Quaternion q1( 0.0f, 1.0f, 1.2f, 1.3f );
+ Quaternion q1(0.0f, 1.0f, 1.2f, 1.3f);
Quaternion q2 = q1.Exp();
- Quaternion r2( -0.4452, 0.4406, 0.5287, 0.5728 );
+ Quaternion r2(-0.4452, 0.4406, 0.5287, 0.5728);
- DALI_TEST_EQUALS( q2.Length(), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2.Length(), 1.0f, 0.01f, TEST_LOCATION);
- DALI_TEST_EQUALS( q2, r2, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, r2, 0.001f, TEST_LOCATION);
// Note, this trick only works when |v| < pi, which it is!
Quaternion q3 = q2.Log();
- DALI_TEST_EQUALS( q1, q3, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q3, 0.01f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionExpP02(void)
{
- Quaternion q1( 0.0f, 0.0f, 0.0f, 0.0f );
+ Quaternion q1(0.0f, 0.0f, 0.0f, 0.0f);
Quaternion q2 = q1.Exp();
- Quaternion r2( 1.0f, 0.0f, 0.0f, 0.0f );
+ Quaternion r2(1.0f, 0.0f, 0.0f, 0.0f);
- DALI_TEST_EQUALS( q2.Length(), 1.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2.Length(), 1.0f, 0.01f, TEST_LOCATION);
- DALI_TEST_EQUALS( q2, r2, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, r2, 0.001f, TEST_LOCATION);
// Note, this trick only works when |v| < pi, which it is!
Quaternion q3 = q2.Log();
- DALI_TEST_EQUALS( q1, q3, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q3, 0.01f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionExpN(void)
{
- Quaternion q( Radian( 0.0f ), Vector3(5.0f, 6.0f, 7.0f) );
+ Quaternion q(Radian(0.0f), Vector3(5.0f, 6.0f, 7.0f));
// q.w is non-zero. Should assert.
try
{
q.Exp();
- DALI_TEST_CHECK( false );
+ DALI_TEST_CHECK(false);
}
- catch( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
}
-
int UtcDaliQuaternionLogP01(void)
{
- Quaternion q( Radian( Math::PI*0.73f ), Vector3(2,3,4) );
+ Quaternion q(Radian(Math::PI * 0.73f), Vector3(2, 3, 4));
Quaternion q2 = q;
q2.Normalize();
Quaternion r = q2.Log();
- DALI_TEST_EQUALS( r.mVector.w, 0.0f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(r.mVector.w, 0.0f, 0.01f, TEST_LOCATION);
Quaternion r2 = r.Exp();
- DALI_TEST_EQUALS( r2, q2, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(r2, q2, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionLogP02(void)
{
- Quaternion q1( 1.0f, 0.0f, 0.0f, 0.0f );
- Quaternion r1( 0.0f, 0.0f, 0.0f, 0.0f );
+ Quaternion q1(1.0f, 0.0f, 0.0f, 0.0f);
+ Quaternion r1(0.0f, 0.0f, 0.0f, 0.0f);
Quaternion q2 = q1.Log();
- DALI_TEST_EQUALS( q2, r1, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q2, r1, 0.01f, TEST_LOCATION);
Quaternion q3 = q2.Exp();
- DALI_TEST_EQUALS( q1, q3, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(q1, q3, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionLerpP(void)
{
- Quaternion q1( Radian( Degree( -80 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
- Quaternion q2( Radian( Degree( 80 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
+ Quaternion q1(Radian(Degree(-80)), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q2(Radian(Degree(80)), Vector3(0.0f, 0.0f, 1.0f));
- Quaternion p = Quaternion::Lerp( q1, q2, 0.0f );
- DALI_TEST_EQUALS( p, q1, 0.001f, TEST_LOCATION );
+ Quaternion p = Quaternion::Lerp(q1, q2, 0.0f);
+ DALI_TEST_EQUALS(p, q1, 0.001f, TEST_LOCATION);
- p = Quaternion::Lerp( q1, q2, 1.0f );
- DALI_TEST_EQUALS( p, q2, 0.001f, TEST_LOCATION );
+ p = Quaternion::Lerp(q1, q2, 1.0f);
+ DALI_TEST_EQUALS(p, q2, 0.001f, TEST_LOCATION);
- p = Quaternion::Lerp( q1, q2, 0.5f );
- Quaternion r1 = ( q1 + q2 ) * 0.5f;
+ p = Quaternion::Lerp(q1, q2, 0.5f);
+ Quaternion r1 = (q1 + q2) * 0.5f;
r1.Normalize();
- DALI_TEST_EQUALS( p, r1, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(p, r1, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliQuaternionSlerpP01(void)
{
- Quaternion q1(Radian(M_PI/4.0f), Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q2(Radian(-M_PI/4.0f), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q1(Radian(M_PI / 4.0f), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q2(Radian(-M_PI / 4.0f), Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q = Quaternion::Slerp( q1, q2, 0.0f );
- DALI_TEST_EQUALS( q, q1, 0.001, TEST_LOCATION );
+ Quaternion q = Quaternion::Slerp(q1, q2, 0.0f);
+ DALI_TEST_EQUALS(q, q1, 0.001, TEST_LOCATION);
- q = Quaternion::Slerp( q1, q2, 1.0f );
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
+ q = Quaternion::Slerp(q1, q2, 1.0f);
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
// @ 25%, will be at M_PI/8
- q = Quaternion::Slerp( q1, q2, 0.25f );
+ q = Quaternion::Slerp(q1, q2, 0.25f);
Vector3 axis;
- Radian angle;
- bool converted = q.ToAxisAngle( axis, angle );
- DALI_TEST_EQUALS( converted, true, TEST_LOCATION );
- DALI_TEST_EQUALS( angle.radian, Math::PI/8.0f, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.x, 0.0f, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.y, 0.0f, 0.001, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.z, 1.0f, 0.001, TEST_LOCATION );
+ Radian angle;
+ bool converted = q.ToAxisAngle(axis, angle);
+ DALI_TEST_EQUALS(converted, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(angle.radian, Math::PI / 8.0f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.x, 0.0f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.y, 0.0f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.z, 1.0f, 0.001, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliQuaternionSlerpP02(void)
{
- Quaternion q1( Dali::ANGLE_30, Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q2( Dali::ANGLE_90, Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q1(Dali::ANGLE_30, Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q2(Dali::ANGLE_90, Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q = Quaternion::Slerp( q1, q2, 0.0f );
+ Quaternion q = Quaternion::Slerp(q1, q2, 0.0f);
- DALI_TEST_EQUALS( q, q1, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q, q1, 0.001, TEST_LOCATION);
- q = Quaternion::Slerp( q1, q2, 1.0f );
+ q = Quaternion::Slerp(q1, q2, 1.0f);
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
// @ 50%, will be at M_PI/3 around z
- q = Quaternion::Slerp( q1, q2, 0.5f );
+ q = Quaternion::Slerp(q1, q2, 0.5f);
- Quaternion r( Dali::ANGLE_60, Vector3( 0.0f, 0.0f, 1.0f));
- DALI_TEST_EQUALS( q, r, 0.001, TEST_LOCATION );
+ Quaternion r(Dali::ANGLE_60, Vector3(0.0f, 0.0f, 1.0f));
+ DALI_TEST_EQUALS(q, r, 0.001, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionSlerpP03(void)
{
- Quaternion q1( Radian( Degree( 125 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
- Quaternion q2( Radian( Degree( -125 ) ), Vector3( 0.002f, 0.001f, 1.001f ) );
+ Quaternion q1(Radian(Degree(125)), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q2(Radian(Degree(-125)), Vector3(0.002f, 0.001f, 1.001f));
- Quaternion q = Quaternion::Slerp( q1, q2, 0.0f );
- DALI_TEST_EQUALS( q, q1, 0.001, TEST_LOCATION );
+ Quaternion q = Quaternion::Slerp(q1, q2, 0.0f);
+ DALI_TEST_EQUALS(q, q1, 0.001, TEST_LOCATION);
- q = Quaternion::Slerp( q1, q2, 1.0f );
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
+ q = Quaternion::Slerp(q1, q2, 1.0f);
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
q = Quaternion::Slerp(q1, q2, 0.05f);
Vector3 axis;
- Radian angle;
- bool converted = q.ToAxisAngle(axis, angle);
+ Radian angle;
+ bool converted = q.ToAxisAngle(axis, angle);
DALI_TEST_EQUALS(converted, true, TEST_LOCATION);
- DALI_TEST_EQUALS( axis.x, 0.0f, 0.01, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.y, 0.0f, 0.01, TEST_LOCATION );
- DALI_TEST_EQUALS( axis.z, 1.0f, 0.01, TEST_LOCATION );
+ DALI_TEST_EQUALS(axis.x, 0.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.y, 0.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.z, 1.0f, 0.01, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliQuaternionSlerpP04(void)
{
- Quaternion q1( Radian( Degree( 120 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
- Quaternion q2( Radian( Degree( 130 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
+ Quaternion q1(Radian(Degree(120)), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q2(Radian(Degree(130)), Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q = Quaternion::Slerp( q1, q2, 0.0f );
- DALI_TEST_EQUALS( q, q1, 0.001, TEST_LOCATION );
+ Quaternion q = Quaternion::Slerp(q1, q2, 0.0f);
+ DALI_TEST_EQUALS(q, q1, 0.001, TEST_LOCATION);
- q = Quaternion::Slerp( q1, q2, 1.0f );
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
+ q = Quaternion::Slerp(q1, q2, 1.0f);
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
q = Quaternion::Slerp(q1, q2, 0.5f);
Vector3 axis;
- Radian angle;
- bool converted = q.ToAxisAngle(axis, angle);
+ Radian angle;
+ bool converted = q.ToAxisAngle(axis, angle);
DALI_TEST_EQUALS(converted, true, TEST_LOCATION);
DALI_TEST_EQUALS(angle.radian, float(Radian(Degree(125))), 0.01f, TEST_LOCATION);
- DALI_TEST_EQUALS(axis.x, 0.0f, 0.01, TEST_LOCATION);
- DALI_TEST_EQUALS(axis.y, 0.0f, 0.01, TEST_LOCATION);
- DALI_TEST_EQUALS(axis.z, 1.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.x, 0.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.y, 0.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.z, 1.0f, 0.01, TEST_LOCATION);
END_TEST;
}
-
-
int UtcDaliQuaternionSlerpNoInvertP01(void)
{
- Quaternion q1( Dali::ANGLE_45, Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q1(Dali::ANGLE_45, Vector3(0.0f, 0.0f, 1.0f));
Quaternion q2(-Dali::ANGLE_45, Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q = Quaternion::SlerpNoInvert( q1, q2, 0.0f );
- DALI_TEST_EQUALS( q, q1, 0.001, TEST_LOCATION );
+ Quaternion q = Quaternion::SlerpNoInvert(q1, q2, 0.0f);
+ DALI_TEST_EQUALS(q, q1, 0.001, TEST_LOCATION);
- q = Quaternion::SlerpNoInvert( q1, q2, 1.0f );
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
+ q = Quaternion::SlerpNoInvert(q1, q2, 1.0f);
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
// @ 25%, will be at M_PI/8
q = Quaternion::SlerpNoInvert(q1, q2, 0.25f);
Vector3 axis;
- Radian angle;
- bool converted = q.ToAxisAngle(axis, angle);
+ Radian angle;
+ bool converted = q.ToAxisAngle(axis, angle);
DALI_TEST_EQUALS(converted, true, TEST_LOCATION);
- DALI_TEST_EQUALS(angle.radian, Math::PI/8.0f, 0.001, TEST_LOCATION);
+ DALI_TEST_EQUALS(angle.radian, Math::PI / 8.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(axis.x, 0.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(axis.y, 0.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(axis.z, 1.0f, 0.001, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionSlerpNoInvertP02(void)
{
- Quaternion q1( Radian( Degree( 120 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
- Quaternion q2( Radian( Degree( 130 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
+ Quaternion q1(Radian(Degree(120)), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q2(Radian(Degree(130)), Vector3(0.0f, 0.0f, 1.0f));
- Quaternion q = Quaternion::SlerpNoInvert( q1, q2, 0.0f );
- DALI_TEST_EQUALS( q, q1, 0.001, TEST_LOCATION );
+ Quaternion q = Quaternion::SlerpNoInvert(q1, q2, 0.0f);
+ DALI_TEST_EQUALS(q, q1, 0.001, TEST_LOCATION);
- q = Quaternion::SlerpNoInvert( q1, q2, 1.0f );
- DALI_TEST_EQUALS( q, q2, 0.001, TEST_LOCATION );
+ q = Quaternion::SlerpNoInvert(q1, q2, 1.0f);
+ DALI_TEST_EQUALS(q, q2, 0.001, TEST_LOCATION);
q = Quaternion::SlerpNoInvert(q1, q2, 0.5f);
Vector3 axis;
- Radian angle;
- bool converted = q.ToAxisAngle(axis, angle);
+ Radian angle;
+ bool converted = q.ToAxisAngle(axis, angle);
DALI_TEST_EQUALS(converted, true, TEST_LOCATION);
DALI_TEST_EQUALS(angle.radian, float(Radian(Degree(125))), 0.01f, TEST_LOCATION);
- DALI_TEST_EQUALS(axis.x, 0.0f, 0.01, TEST_LOCATION);
- DALI_TEST_EQUALS(axis.y, 0.0f, 0.01, TEST_LOCATION);
- DALI_TEST_EQUALS(axis.z, 1.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.x, 0.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.y, 0.0f, 0.01, TEST_LOCATION);
+ DALI_TEST_EQUALS(axis.z, 1.0f, 0.01, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliQuaternionSquadP(void)
{
- Quaternion q1( Radian( Degree( 45 ) ), Vector3( 0.0f, 0.0f, 1.0f ) );
- Quaternion q1out( Radian( Degree( 40 ) ), Vector3( 0.0f, 1.0f, 2.0f ) );
- Quaternion q2in( Radian( Degree( 35 ) ), Vector3( 0.0f, 2.0f, 3.0f ) );
- Quaternion q2( Radian( Degree( 30 ) ), Vector3( 0.0f, 1.0f, 3.0f ) );
+ Quaternion q1(Radian(Degree(45)), Vector3(0.0f, 0.0f, 1.0f));
+ Quaternion q1out(Radian(Degree(40)), Vector3(0.0f, 1.0f, 2.0f));
+ Quaternion q2in(Radian(Degree(35)), Vector3(0.0f, 2.0f, 3.0f));
+ Quaternion q2(Radian(Degree(30)), Vector3(0.0f, 1.0f, 3.0f));
- Quaternion q = Quaternion::Squad( q1, q2, q1out, q2in, 0.0f );
- DALI_TEST_EQUALS( q, q1, 0.001f, TEST_LOCATION );
+ Quaternion q = Quaternion::Squad(q1, q2, q1out, q2in, 0.0f);
+ DALI_TEST_EQUALS(q, q1, 0.001f, TEST_LOCATION);
- q = Quaternion::Squad( q1, q2, q1out, q2in, 1.0f );
- DALI_TEST_EQUALS( q, q2, 0.001f, TEST_LOCATION );
+ q = Quaternion::Squad(q1, q2, q1out, q2in, 1.0f);
+ DALI_TEST_EQUALS(q, q2, 0.001f, TEST_LOCATION);
// Don't know what actual value should be, but can make some informed guesses.
q = Quaternion::Squad(q1, q2, q1out, q2in, 0.5f);
- Radian angle;
+ Radian angle;
Vector3 axis;
q.Normalize();
- q.ToAxisAngle( axis, angle );
+ q.ToAxisAngle(axis, angle);
- if( angle < 0.0f )
+ if(angle < 0.0f)
{
q = -q; // Might get negative quat
- q.ToAxisAngle( axis, angle );
+ q.ToAxisAngle(axis, angle);
}
float deg = Degree(angle).degree;
DALI_TEST_CHECK(deg >= 0 && deg <= 90);
int UtcDaliAngleBetweenP(void)
{
- Quaternion q1( ANGLE_45, ANGLE_0, ANGLE_0 );
- Quaternion q2(Radian(Degree(47)), ANGLE_0, ANGLE_0 );
+ Quaternion q1(ANGLE_45, ANGLE_0, ANGLE_0);
+ Quaternion q2(Radian(Degree(47)), ANGLE_0, ANGLE_0);
DALI_TEST_EQUALS(Quaternion::AngleBetween(q1, q2), fabsf(Radian(Degree(45)) - Radian(Degree(47))), 0.001f, TEST_LOCATION);
- Quaternion q3( Radian( Degree( 80 ) ), Vector3::YAXIS );
- Quaternion q4( Radian( Degree( 90 ) ), Vector3::YAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q3, q4 ), fabsf( Radian( Degree( 80 ) ) - Radian( Degree( 90 ) ) ), 0.001f, TEST_LOCATION );
+ Quaternion q3(Radian(Degree(80)), Vector3::YAXIS);
+ Quaternion q4(Radian(Degree(90)), Vector3::YAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q3, q4), fabsf(Radian(Degree(80)) - Radian(Degree(90))), 0.001f, TEST_LOCATION);
- Quaternion q5( Radian( Degree( 0 ) ), Vector3::YAXIS );
- Quaternion q6( Radian( Degree( 90 ) ), Vector3::XAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q5, q6 ), fabsf( Radian( Degree( 0 ) ) - Radian( Degree( 90 ) ) ), 0.001f, TEST_LOCATION );
+ Quaternion q5(Radian(Degree(0)), Vector3::YAXIS);
+ Quaternion q6(Radian(Degree(90)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q5, q6), fabsf(Radian(Degree(0)) - Radian(Degree(90))), 0.001f, TEST_LOCATION);
- Quaternion q7( Radian( Degree( 0 ) ), Vector3::YAXIS );
- Quaternion q8( Radian( Degree( 0 ) ), Vector3::XAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q7, q8 ), fabsf( Radian( Degree( 0 ) ) - Radian( Degree( 0 ) ) ), 0.001f, TEST_LOCATION );
+ Quaternion q7(Radian(Degree(0)), Vector3::YAXIS);
+ Quaternion q8(Radian(Degree(0)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q7, q8), fabsf(Radian(Degree(0)) - Radian(Degree(0))), 0.001f, TEST_LOCATION);
- Quaternion q9( Radian( Degree( 0 ) ), Vector3::XAXIS );
- Quaternion q10( Radian( Degree( 180 ) ), Vector3::XAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q9, q10 ), fabsf( Radian( Degree( 0 ) ) - Radian( Degree( 180 ) ) ), 0.001f, TEST_LOCATION );
+ Quaternion q9(Radian(Degree(0)), Vector3::XAXIS);
+ Quaternion q10(Radian(Degree(180)), Vector3::XAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q9, q10), fabsf(Radian(Degree(0)) - Radian(Degree(180))), 0.001f, TEST_LOCATION);
- Quaternion q11( Radian( Degree( 1 ) ), Vector3::YAXIS );
- Quaternion q12( Radian( Degree( 240 ) ), Vector3::YAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q11, q12 ), fabsf( Radian( Degree( 1 - 240 + 360 ) ) ), 0.001f, TEST_LOCATION );
+ Quaternion q11(Radian(Degree(1)), Vector3::YAXIS);
+ Quaternion q12(Radian(Degree(240)), Vector3::YAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q11, q12), fabsf(Radian(Degree(1 - 240 + 360))), 0.001f, TEST_LOCATION);
- Quaternion q13( Radian( Degree( 240 ) ), Vector3::YAXIS );
- Quaternion q14( Radian( Degree( 1 ) ), Vector3::YAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q13, q14 ), fabsf( Radian( Degree( 240 - 1 - 360 ) ) ), 0.001f, TEST_LOCATION );
+ Quaternion q13(Radian(Degree(240)), Vector3::YAXIS);
+ Quaternion q14(Radian(Degree(1)), Vector3::YAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q13, q14), fabsf(Radian(Degree(240 - 1 - 360))), 0.001f, TEST_LOCATION);
- Quaternion q15( Radian( Degree( 240 ) ), Vector3::YAXIS );
- Quaternion q16( Radian( Degree( 1 ) ), Vector3::ZAXIS );
- DALI_TEST_EQUALS( Quaternion::AngleBetween( q15, q16 ), Quaternion::AngleBetween( q16, q15 ), 0.001f, TEST_LOCATION );
+ Quaternion q15(Radian(Degree(240)), Vector3::YAXIS);
+ Quaternion q16(Radian(Degree(1)), Vector3::ZAXIS);
+ DALI_TEST_EQUALS(Quaternion::AngleBetween(q15, q16), Quaternion::AngleBetween(q16, q15), 0.001f, TEST_LOCATION);
END_TEST;
}
{
std::ostringstream oss;
- Quaternion quaternion( Dali::ANGLE_180, Vector3::YAXIS );
+ Quaternion quaternion(Dali::ANGLE_180, Vector3::YAXIS);
oss << quaternion;
std::string expectedOutput = "[ Axis: [0, 1, 0], Angle: 180 degrees ]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION );
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-using namespace Dali;
+#include <iostream>
+using namespace Dali;
void utc_dali_radian_startup(void)
{
test_return_value = TET_PASS;
}
-
// Positive test case for constructors
int UtcDaliRadianConstructors01(void)
{
// Default constructor, does not initialise the value
- Radian radian0( 0.0f );
+ Radian radian0(0.0f);
// Test float assignment operator
radian0 = Math::PI;
- DALI_TEST_EQUALS( float(radian0), Math::PI, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(float(radian0), Math::PI, 0.001f, TEST_LOCATION);
// Constructor from float value
- Radian radian1( Math::PI );
- DALI_TEST_EQUALS( float(radian1), Math::PI, 0.001f, TEST_LOCATION );
+ Radian radian1(Math::PI);
+ DALI_TEST_EQUALS(float(radian1), Math::PI, 0.001f, TEST_LOCATION);
// Constructor from a Degree
- Radian radian2( Degree( 180.0f ) );
- DALI_TEST_EQUALS( float(radian2), Math::PI, 0.001f, TEST_LOCATION );
+ Radian radian2(Degree(180.0f));
+ DALI_TEST_EQUALS(float(radian2), Math::PI, 0.001f, TEST_LOCATION);
// Assignment from Degree
- Radian radian3( 0.0f );
- radian3 = Degree( 180.0f );
- DALI_TEST_EQUALS( float(radian3), Math::PI, 0.001f, TEST_LOCATION );
+ Radian radian3(0.0f);
+ radian3 = Degree(180.0f);
+ DALI_TEST_EQUALS(float(radian3), Math::PI, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliRadianCopyConstructor(void)
{
- Radian radian0( Math::PI );
- Radian radian1( radian0 );
- DALI_TEST_EQUALS( float(radian1), Math::PI, 0.001f, TEST_LOCATION );
+ Radian radian0(Math::PI);
+ Radian radian1(radian0);
+ DALI_TEST_EQUALS(float(radian1), Math::PI, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliRadianMoveConstructor(void)
{
- Radian radian0( Math::PI );
- Radian radian1 = std::move( radian0 );
- DALI_TEST_EQUALS( float(radian1), Math::PI, 0.001f, TEST_LOCATION );
+ Radian radian0(Math::PI);
+ Radian radian1 = std::move(radian0);
+ DALI_TEST_EQUALS(float(radian1), Math::PI, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliRadianCopyAssignment(void)
{
- Radian radian0( Math::PI );
+ Radian radian0(Math::PI);
Radian radian1;
radian1 = radian0;
- DALI_TEST_EQUALS( float(radian1), Math::PI, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(float(radian1), Math::PI, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliRadianMoveAssignment(void)
{
- Radian radian0( Math::PI );
+ Radian radian0(Math::PI);
Radian radian1;
- radian1 = std::move( radian0 );
- DALI_TEST_EQUALS( float(radian1), Math::PI, 0.001f, TEST_LOCATION );
+ radian1 = std::move(radian0);
+ DALI_TEST_EQUALS(float(radian1), Math::PI, 0.001f, TEST_LOCATION);
END_TEST;
}
int UtcDaliRadianComparison01(void)
{
// Comparison between radians
- Radian radian0( Math::PI_2 );
- Radian radian1( Math::PI_2 );
- Radian radian2( Math::PI );
+ Radian radian0(Math::PI_2);
+ Radian radian1(Math::PI_2);
+ Radian radian2(Math::PI);
- DALI_TEST_CHECK( radian0 == radian1 );
- DALI_TEST_CHECK( radian0 != radian2 );
+ DALI_TEST_CHECK(radian0 == radian1);
+ DALI_TEST_CHECK(radian0 != radian2);
// Comparison between radian to degree
- Radian radian3( Math::PI );
- Radian radian4( Math::PI_2 );
- Degree degree0( 180.0f );
+ Radian radian3(Math::PI);
+ Radian radian4(Math::PI_2);
+ Degree degree0(180.0f);
- DALI_TEST_CHECK( radian3 == Radian(degree0) );
- DALI_TEST_CHECK( radian4 != Radian(degree0) );
+ DALI_TEST_CHECK(radian3 == Radian(degree0));
+ DALI_TEST_CHECK(radian4 != Radian(degree0));
// Comparison with float
- Radian radian5( Math::PI_2 );
+ Radian radian5(Math::PI_2);
- DALI_TEST_CHECK( radian5 == Math::PI_2 );
- DALI_TEST_CHECK( radian5 != Math::PI );
+ DALI_TEST_CHECK(radian5 == Math::PI_2);
+ DALI_TEST_CHECK(radian5 != Math::PI);
END_TEST;
}
-
// test case for cast operators
int UtcDaliRadianCastOperators01(void)
{
- Radian radian0( Math::PI );
+ Radian radian0(Math::PI);
- const float& value0( radian0.radian );
- DALI_TEST_EQUALS( value0, Math::PI, 0.001f, TEST_LOCATION );
+ const float& value0(radian0.radian);
+ DALI_TEST_EQUALS(value0, Math::PI, 0.001f, TEST_LOCATION);
radian0 = Math::PI_2;
- DALI_TEST_EQUALS( value0, Math::PI_2, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(value0, Math::PI_2, 0.001f, TEST_LOCATION);
- float value1( radian0 );
- DALI_TEST_EQUALS( value1, Math::PI_2, 0.001f, TEST_LOCATION );
+ float value1(radian0);
+ DALI_TEST_EQUALS(value1, Math::PI_2, 0.001f, TEST_LOCATION);
radian0 = Math::PI;
- DALI_TEST_EQUALS( float(radian0), Math::PI, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(float(radian0), Math::PI, 0.001f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRadianCastOperatorEquals(void)
{
Radian a(Math::PI_2);
Radian b(Math::PI_2);
Radian c(Math::PI);
- DALI_TEST_EQUALS( a == a, true, TEST_LOCATION );
- DALI_TEST_EQUALS( a == b, true, TEST_LOCATION );
- DALI_TEST_EQUALS( a == c, false, TEST_LOCATION );
- DALI_TEST_EQUALS( Degree(c) == c, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(a == a, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(a == b, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(a == c, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(Degree(c) == c, true, TEST_LOCATION);
END_TEST;
}
Radian b(Math::PI_2);
Radian c(Math::PI);
- DALI_TEST_EQUALS( a != a, false, TEST_LOCATION );
- DALI_TEST_EQUALS( a != b, false, TEST_LOCATION );
- DALI_TEST_EQUALS( a != c, true, TEST_LOCATION );
- DALI_TEST_EQUALS( Degree(a) != c, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(a != a, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(a != b, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(a != c, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(Degree(a) != c, true, TEST_LOCATION);
END_TEST;
}
Radian a(Math::PI_4);
Radian b(Math::PI_2);
Radian c(Math::PI);
- Radian d(2.0f*Math::PI);
+ Radian d(2.0f * Math::PI);
Radian e(-Math::PI);
DALI_TEST_EQUALS(a < a, false, TEST_LOCATION);
DALI_TEST_EQUALS(d < b, false, TEST_LOCATION);
DALI_TEST_EQUALS(e < b, true, TEST_LOCATION);
- DALI_TEST_EQUALS( Radian(Math::PI_2) < Degree(180.0f), true, TEST_LOCATION);
- DALI_TEST_EQUALS( Radian(Math::PI_2) < Degree(90.0f), false, TEST_LOCATION);
- DALI_TEST_EQUALS( Radian(Math::PI_2) > Degree(45.0f), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(Radian(Math::PI_2) < Degree(180.0f), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(Radian(Math::PI_2) < Degree(90.0f), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(Radian(Math::PI_2) > Degree(45.0f), true, TEST_LOCATION);
- DALI_TEST_EQUALS( Degree(180.0f) > Radian(Math::PI_2), true, TEST_LOCATION);
- DALI_TEST_EQUALS( Degree(90.0f) > Radian(Math::PI_2), false, TEST_LOCATION);
- DALI_TEST_EQUALS( Degree(45.0f) < Radian(Math::PI_2), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(Degree(180.0f) > Radian(Math::PI_2), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(Degree(90.0f) > Radian(Math::PI_2), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(Degree(45.0f) < Radian(Math::PI_2), true, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-using namespace Dali;
+#include <iostream>
+using namespace Dali;
int UtcDaliRandomRangeMethod(void)
{
TestApplication application; // Reset all test adapter return codes
- float a=0, b=1;
- for(size_t i=0; i<100; i++)
+ float a = 0, b = 1;
+ for(size_t i = 0; i < 100; i++)
{
float r = Dali::Random::Range(a, b);
DALI_TEST_CHECK(r >= a && r <= b);
}
- a=100; b=-100;
- for(size_t i=0; i<100; i++)
+ a = 100;
+ b = -100;
+ for(size_t i = 0; i < 100; i++)
{
float r = Dali::Random::Range(a, b);
DALI_TEST_CHECK(r >= b && r <= a);
END_TEST;
}
-
int UtcDaliRandomAxisMethod(void)
{
TestApplication application; // Reset all test adapter return codes
- for(size_t i=0; i<100; i++)
+ for(size_t i = 0; i < 100; i++)
{
Vector4 axis = Dali::Random::Axis();
DALI_TEST_EQUALS(axis.Length(), 1.0f, 0.0001f, TEST_LOCATION);
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
test_return_value = TET_PASS;
}
-
// Positive test case for a method
int UtcDaliRectCons01(void)
{
Rect<float> rect(10.0f, 20.0f, 400.0f, 200.0f);
- Rect<float> r2 = std::move( rect );
+ Rect<float> r2 = std::move(rect);
DALI_TEST_EQUALS(r2.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(r2.y, 20.0f, 0.001, TEST_LOCATION);
Rect<float> rect(10.0f, 20.0f, 400.0f, 200.0f);
Rect<float> r2;
- r2 = std::move( rect );
+ r2 = std::move(rect);
DALI_TEST_EQUALS(r2.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(r2.y, 20.0f, 0.001, TEST_LOCATION);
{
TestApplication application;
- Rect<int> ri;
- Rect<float> rf(10.0f, 20.0f, 400.0f, 200.0f);
- Rect<float> rf2;
- Rect<float> rf3(10.0f, 20.0f, 0.0f, 200.0f);
- Rect<float> rf4(10.0f, 20.0f, 400.0f, 0.0f);
- Rect<double> rd(10.0, 20.0, 0.0, 200.0);
+ Rect<int> ri;
+ Rect<float> rf(10.0f, 20.0f, 400.0f, 200.0f);
+ Rect<float> rf2;
+ Rect<float> rf3(10.0f, 20.0f, 0.0f, 200.0f);
+ Rect<float> rf4(10.0f, 20.0f, 400.0f, 0.0f);
+ Rect<double> rd(10.0, 20.0, 0.0, 200.0);
Rect<unsigned int> ru(0u, 0u, 4u, 0u);
DALI_TEST_CHECK(!rf.IsEmpty());
END_TEST;
}
-
int UtcDaliRectArea(void)
{
TestApplication application;
END_TEST;
}
-
int UtcDaliRectIntersects(void)
{
TestApplication application;
- Rect<float> rf1( 10.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf2( 10.0f, 120.0f, 200.0f, 200.0f);
- Rect<float> rf3( 10.0f, -80.0f, 200.0f, 200.0f);
- Rect<float> rf4(110.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf5(-90.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf1(10.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf2(10.0f, 120.0f, 200.0f, 200.0f);
+ Rect<float> rf3(10.0f, -80.0f, 200.0f, 200.0f);
+ Rect<float> rf4(110.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf5(-90.0f, 20.0f, 200.0f, 200.0f);
Rect<float> rf6(1000.0f, 1200.0f, 10.0f, 10.0f);
DALI_TEST_CHECK(rf1.Intersects(rf2));
END_TEST;
}
-
-
int UtcDaliRectContains(void)
{
TestApplication application;
- Rect<float> rf1( 10.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf1(10.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf2( 10.0f, 120.0f, 200.0f, 200.0f);
- Rect<float> rf3( 10.0f, -80.0f, 200.0f, 200.0f);
- Rect<float> rf4(110.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf5(-90.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf2(10.0f, 120.0f, 200.0f, 200.0f);
+ Rect<float> rf3(10.0f, -80.0f, 200.0f, 200.0f);
+ Rect<float> rf4(110.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf5(-90.0f, 20.0f, 200.0f, 200.0f);
Rect<float> rf6(1000.0f, 1200.0f, 10.0f, 10.0f);
- Rect<float> rf7( 50.0f, 70.0f, 50.0f, 50.0f);
+ Rect<float> rf7(50.0f, 70.0f, 50.0f, 50.0f);
- Rect<float> rf8( 10.0f, 20.0f, 100.0f, 100.0f);
- Rect<float> rf9( 110.0f, 20.0f, 100.0f, 100.0f);
- Rect<float> rf10( 110.0f, 120.0f, 100.0f, 100.0f);
- Rect<float> rf11( 10.0f, 120.0f, 100.0f, 100.0f);
+ Rect<float> rf8(10.0f, 20.0f, 100.0f, 100.0f);
+ Rect<float> rf9(110.0f, 20.0f, 100.0f, 100.0f);
+ Rect<float> rf10(110.0f, 120.0f, 100.0f, 100.0f);
+ Rect<float> rf11(10.0f, 120.0f, 100.0f, 100.0f);
DALI_TEST_CHECK(rf1.Contains(rf1));
DALI_TEST_CHECK(!rf1.Contains(rf2));
END_TEST;
}
-
int UtcDaliRectOperatorNotEquals(void)
{
TestApplication application;
- Rect<float> rf1( 10.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf2( 10.0f, 120.0f, 200.0f, 200.0f);
- Rect<float> rf3( 10.0f, -80.0f, 200.0f, 200.0f);
- Rect<float> rf4(110.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf5(-90.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf1(10.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf2(10.0f, 120.0f, 200.0f, 200.0f);
+ Rect<float> rf3(10.0f, -80.0f, 200.0f, 200.0f);
+ Rect<float> rf4(110.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf5(-90.0f, 20.0f, 200.0f, 200.0f);
Rect<float> rf6(1000.0f, 1200.0f, 10.0f, 10.0f);
- Rect<float> rf7( 50.0f, 70.0f, 50.0f, 50.0f);
- Rect<float> rf8( 10.0f, 20.0f, 100.0f, 100.0f);
- Rect<float> rf9( 110.0f, 20.0f, 100.0f, 100.0f);
- Rect<float> rf10( 110.0f, 120.0f, 100.0f, 100.0f);
- Rect<float> rf11( 10.0f, 120.0f, 100.0f, 100.0f);
+ Rect<float> rf7(50.0f, 70.0f, 50.0f, 50.0f);
+ Rect<float> rf8(10.0f, 20.0f, 100.0f, 100.0f);
+ Rect<float> rf9(110.0f, 20.0f, 100.0f, 100.0f);
+ Rect<float> rf10(110.0f, 120.0f, 100.0f, 100.0f);
+ Rect<float> rf11(10.0f, 120.0f, 100.0f, 100.0f);
DALI_TEST_CHECK(rf1 != rf2);
DALI_TEST_CHECK(rf1 != rf3);
END_TEST;
}
-
int UtcDaliRectOperatorEquals(void)
{
TestApplication application;
- Rect<float> rf1( 10.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf1p( 10.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf1(10.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf1p(10.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf2(110.0f, 20.0f, 200.0f, 200.0f);
- Rect<float> rf3( 10.0f, 120.0f, 200.0f, 200.0f);
- Rect<float> rf4( 10.0f, 20.0f, 300.0f, 200.0f);
- Rect<float> rf5( 10.0f, 20.0f, 200.0f, 500.0f);
+ Rect<float> rf2(110.0f, 20.0f, 200.0f, 200.0f);
+ Rect<float> rf3(10.0f, 120.0f, 200.0f, 200.0f);
+ Rect<float> rf4(10.0f, 20.0f, 300.0f, 200.0f);
+ Rect<float> rf5(10.0f, 20.0f, 200.0f, 500.0f);
- Rect<float> rf6( 0.0f, 0.0f, 9.0f, 10.0f);
+ Rect<float> rf6(0.0f, 0.0f, 9.0f, 10.0f);
DALI_TEST_CHECK(rf1 == rf1p);
DALI_TEST_CHECK(rf1 == rf1);
DALI_TEST_CHECK(!(rf1 == rf5));
DALI_TEST_CHECK(!(rf1 == rf6));
-
// integers
- Rect<int> ri1( 10, 20, 200, 200 );
- Rect<int> ri1p( 10, 20, 200, 200 );
+ Rect<int> ri1(10, 20, 200, 200);
+ Rect<int> ri1p(10, 20, 200, 200);
DALI_TEST_CHECK(ri1 == ri1p);
END_TEST;
int UtcDaliRectOStreamOperatorP(void)
{
- TestApplication application;
+ TestApplication application;
std::ostringstream oss;
- Rect<int> rect( 1, 2, 10, 10 );
+ Rect<int> rect(1, 2, 10, 10);
oss << rect;
std::string expectedOutput = "[1, 2, 10, 10]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/events/hit-test-algorithm.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/hit-test-algorithm.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/dali-core.h>
+#include <mesh-builder.h>
+#include <stdlib.h>
#include <test-native-image.h>
-#include <mesh-builder.h>
+#include <iostream>
-#define BOOLSTR(x) ((x)?"T":"F")
+#define BOOLSTR(x) ((x) ? "T" : "F")
//& set: DaliRenderTask
namespace // unnamed namespace
{
-
-const int RENDER_FRAME_INTERVAL = 16; ///< Duration of each frame in ms. (at approx 60FPS)
+const int RENDER_FRAME_INTERVAL = 16; ///< Duration of each frame in ms. (at approx 60FPS)
/*
* Simulate time passed by.
{
int time = 0;
- for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
+ for(int i = 0; i <= (duration / RENDER_FRAME_INTERVAL); i++)
{
application.SendNotification();
application.Render(RENDER_FRAME_INTERVAL);
struct RenderTaskFinished
{
- RenderTaskFinished( bool& finished )
- : finished( finished )
+ RenderTaskFinished(bool& finished)
+ : finished(finished)
{
}
- void operator()( RenderTask& renderTask )
+ void operator()(RenderTask& renderTask)
{
finished = true;
}
struct RenderTaskFinishedRemoveSource
{
- RenderTaskFinishedRemoveSource( bool& finished )
- : finished( finished ),
+ RenderTaskFinishedRemoveSource(bool& finished)
+ : finished(finished),
finishedOnce(false)
{
}
- void operator()( RenderTask& renderTask )
+ void operator()(RenderTask& renderTask)
{
DALI_TEST_CHECK(finishedOnce == false);
- finished = true;
- finishedOnce = true;
+ finished = true;
+ finishedOnce = true;
Actor srcActor = renderTask.GetSourceActor();
UnparentAndReset(srcActor);
}
bool& finished;
- bool finishedOnce;
+ bool finishedOnce;
};
struct RenderTaskFinishedRenderAgain
{
- RenderTaskFinishedRenderAgain( bool& finished )
- : finished( finished ),
+ RenderTaskFinishedRenderAgain(bool& finished)
+ : finished(finished),
finishedOnce(false)
{
}
- void operator()( RenderTask& renderTask )
+ void operator()(RenderTask& renderTask)
{
DALI_TEST_CHECK(finishedOnce == false);
- finished = true;
+ finished = true;
finishedOnce = true;
renderTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
}
bool& finished;
- bool finishedOnce;
+ bool finishedOnce;
};
-
-bool TestScreenToFrameBufferFunction( Vector2& coordinates )
+bool TestScreenToFrameBufferFunction(Vector2& coordinates)
{
- coordinates = coordinates + Vector2( 1, 2 );
+ coordinates = coordinates + Vector2(1, 2);
return true;
}
Actor CreateRenderableActorSuccess(TestApplication& application, std::string filename)
{
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 80.0f, 80.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(80.0f, 80.0f));
return actor;
}
}
RenderTask CreateRenderTask(TestApplication& application,
- CameraActor offscreenCamera,
- Actor rootActor, // Reset default render task to point at this actor
- Actor secondRootActor, // Source actor
- unsigned int refreshRate,
- bool glSync)
+ CameraActor offscreenCamera,
+ Actor rootActor, // Reset default render task to point at this actor
+ Actor secondRootActor, // Source actor
+ unsigned int refreshRate,
+ bool glSync)
{
// Change main render task to use a different root
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- taskList.GetTask(0u).SetSourceActor( rootActor );
+ taskList.GetTask(0u).SetSourceActor(rootActor);
- FrameBuffer frameBuffer = FrameBuffer::New(10,10);
- if( glSync )
+ FrameBuffer frameBuffer = FrameBuffer::New(10, 10);
+ if(glSync)
{
NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
- Texture texture = Texture::New(*testNativeImagePtr);
+ Texture texture = Texture::New(*testNativeImagePtr);
frameBuffer.AttachColorTexture(texture);
}
// Don't draw output framebuffer // '
RenderTask newTask = taskList.CreateTask();
- newTask.SetCameraActor( offscreenCamera );
- newTask.SetSourceActor( secondRootActor );
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( refreshRate );
- newTask.SetFrameBuffer( frameBuffer );
- newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, glSync );
+ newTask.SetCameraActor(offscreenCamera);
+ newTask.SetSourceActor(secondRootActor);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(refreshRate);
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, glSync);
return newTask;
}
-bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating, int lineNumber )
+bool UpdateRender(TestApplication& application, TraceCallStack& callStack, bool testDrawn, bool& finishedSig, bool testFinished, bool testKeepUpdating, int lineNumber)
{
finishedSig = false;
callStack.Reset();
application.SendNotification();
bool sigPassed = false;
- if( testFinished )
+ if(testFinished)
{
sigPassed = finishedSig;
}
else
{
- sigPassed = ! finishedSig;
+ sigPassed = !finishedSig;
}
bool drawResult = callStack.FindMethod("DrawElements") || callStack.FindMethod("DrawArrays");
bool drawPassed = false;
- if( testDrawn )
+ if(testDrawn)
{
drawPassed = drawResult;
}
drawPassed = !drawResult;
}
- bool keepUpdating = (application.GetUpdateStatus() != 0);
+ bool keepUpdating = (application.GetUpdateStatus() != 0);
bool keepUpdatingPassed = false;
- if( testKeepUpdating )
+ if(testKeepUpdating)
{
keepUpdatingPassed = keepUpdating;
}
bool result = (sigPassed && drawPassed && keepUpdatingPassed);
tet_printf("UpdateRender: Expected: Draw:%s Signal:%s KeepUpdating: %s Actual: Draw:%s Signal:%s KeepUpdating: %s %s, line %d\n",
- BOOLSTR(testDrawn), BOOLSTR(testFinished), BOOLSTR(testKeepUpdating),
- BOOLSTR(drawResult), BOOLSTR(finishedSig), BOOLSTR(keepUpdating),
- result ? "Passed":"Failed",
- lineNumber );
+ BOOLSTR(testDrawn),
+ BOOLSTR(testFinished),
+ BOOLSTR(testKeepUpdating),
+ BOOLSTR(drawResult),
+ BOOLSTR(finishedSig),
+ BOOLSTR(keepUpdating),
+ result ? "Passed" : "Failed",
+ lineNumber);
return result;
}
} // unnamed namespace
-
/****************************************************************************************************/
/****************************************************************************************************/
/******************************** TEST CASES BELOW **********************************************/
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- BaseHandle base = taskList.GetTask( 0u );
- DALI_TEST_CHECK( base );
+ BaseHandle base = taskList.GetTask(0u);
+ DALI_TEST_CHECK(base);
- RenderTask task = RenderTask::DownCast( base );
- DALI_TEST_CHECK( task );
+ RenderTask task = RenderTask::DownCast(base);
+ DALI_TEST_CHECK(task);
// Try calling a method
- DALI_TEST_CHECK( task.GetSourceActor() );
+ DALI_TEST_CHECK(task.GetSourceActor());
END_TEST;
}
Actor actor = Actor::New();
- RenderTask task = RenderTask::DownCast( actor );
- DALI_TEST_CHECK( ! task );
+ RenderTask task = RenderTask::DownCast(actor);
+ DALI_TEST_CHECK(!task);
END_TEST;
}
Actor srcActor;
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask renderTask = taskList.CreateTask();
renderTask.SetSourceActor(srcActor);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( ! renderTask.GetSourceActor() );
+ DALI_TEST_CHECK(!renderTask.GetSourceActor());
END_TEST;
}
-
int UtcDaliRenderTaskSetSourceActorP01(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::SetSourceActor() Positive - check that setting a non-renderable actor stops existing source actor being rendered ");
- Integration::Scene stage = application.GetScene();
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor newActor = CreateRenderableActor( img );
- newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- stage.Add( newActor );
+ Texture img = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
Actor nonRenderableActor = Actor::New();
- stage.Add( nonRenderableActor );
+ stage.Add(nonRenderableActor);
// Stop the newActor from being rendered by changing the source actor
- DALI_TEST_CHECK( nonRenderableActor );
- task.SetSourceActor( nonRenderableActor );
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
+ DALI_TEST_CHECK(nonRenderableActor);
+ task.SetSourceActor(nonRenderableActor);
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == nonRenderableActor);
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Enable(true);
// Update & Render nothing!
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskSetSourceActorP02(void)
{
TestApplication application;
RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
-
+ DALI_TEST_CHECK(actor);
- Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor newActor = CreateRenderableActor( img );
- newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- stage.Add( newActor );
+ Texture img = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
Actor nonRenderableActor = Actor::New();
- stage.Add( nonRenderableActor );
+ stage.Add(nonRenderableActor);
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Enable(true);
// Stop the newActor from being rendered by changing the source actor
- DALI_TEST_CHECK( nonRenderableActor );
- task.SetSourceActor( nonRenderableActor );
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == nonRenderableActor );
+ DALI_TEST_CHECK(nonRenderableActor);
+ task.SetSourceActor(nonRenderableActor);
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == nonRenderableActor);
// Update & Render nothing!
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
drawTrace.Reset();
// Set newActor as the new source Actor
- task.SetSourceActor( newActor );
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == newActor );
+ task.SetSourceActor(newActor);
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == newActor);
// Update & Render the newActor
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that the newActor was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::SetSourceActor (on/off stage testing)");
- Integration::Scene stage = application.GetScene();
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Enable(true);
- Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor newActor = CreateRenderableActor( img );
- newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- task.SetSourceActor( newActor );
+ Texture img = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ task.SetSourceActor(newActor);
// Don't add newActor to stage yet //'
// Update & Render with the actor initially off-stage
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
// Now add to stage
- stage.Add( newActor );
+ stage.Add(newActor);
// Update & Render with the actor on-stage
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that the newActor was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
drawTrace.Reset();
// Now remove from stage
- stage.Remove( newActor );
+ stage.Remove(newActor);
// Update & Render with the actor off-stage
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::SetSourceActor (empty handle case)");
- Integration::Scene stage = application.GetScene();
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor newActor = CreateRenderableActor( img );
- newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- stage.Add( newActor );
+ Texture img = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
Actor nonRenderableActor = Actor::New();
- stage.Add( nonRenderableActor );
+ stage.Add(nonRenderableActor);
// Set with empty handle
- task.SetSourceActor( Actor() );
- DALI_TEST_CHECK( ! task.GetSourceActor() );
+ task.SetSourceActor(Actor());
+ DALI_TEST_CHECK(!task.GetSourceActor());
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Enable(true);
// Update & Render nothing!
application.Render();
// Check that nothing was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 0, TEST_LOCATION);
// Set with non-empty handle
- task.SetSourceActor( newActor );
- DALI_TEST_CHECK( task.GetSourceActor() == newActor );
+ task.SetSourceActor(newActor);
+ DALI_TEST_CHECK(task.GetSourceActor() == newActor);
// Update & Render the newActor
application.GetGlAbstraction().ClearBoundTextures();
application.Render();
// Check that the newActor was rendered
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Testing RenderTask::SetSourceActor - Set a source actor and destroy the source actor" );
+ tet_infoline("Testing RenderTask::SetSourceActor - Set a source actor and destroy the source actor");
- Integration::Scene stage = application.GetScene();
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
- Texture img = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
+ Texture img = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
- Actor newActor = CreateRenderableActor( img );
- newActor.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- stage.Add( newActor );
+ Actor newActor = CreateRenderableActor(img);
+ newActor.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ stage.Add(newActor);
- task.SetSourceActor( newActor );
+ task.SetSourceActor(newActor);
- DALI_TEST_CHECK( task.GetSourceActor() != actor );
- DALI_TEST_CHECK( task.GetSourceActor() == newActor );
+ DALI_TEST_CHECK(task.GetSourceActor() != actor);
+ DALI_TEST_CHECK(task.GetSourceActor() == newActor);
application.SendNotification();
application.Render();
// Destroy the source actor
- stage.Remove( newActor );
+ stage.Remove(newActor);
newActor.Reset();
- DALI_TEST_CHECK( !task.GetSourceActor() ); // The source actor should be an empty handle.
+ DALI_TEST_CHECK(!task.GetSourceActor()); // The source actor should be an empty handle.
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetSourceActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
// By default the entire scene should be rendered
- Actor root = application.GetScene().GetLayer( 0 );
- DALI_TEST_CHECK( root == actor );
+ Actor root = application.GetScene().GetLayer(0);
+ DALI_TEST_CHECK(root == actor);
END_TEST;
}
tet_infoline("Testing RenderTask::GetSourceActor() Create a new render task, Add a new actor to the stage and set it as the source of the new render task. Get its source actor and check that it is equivalent to what was set.");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
- Actor actor = Actor::New();
+ RenderTask task = taskList.CreateTask();
+ Actor actor = Actor::New();
application.GetScene().Add(actor);
- task.SetSourceActor( actor );
+ task.SetSourceActor(actor);
- DALI_TEST_EQUALS( actor, task.GetSourceActor(), TEST_LOCATION );
+ DALI_TEST_EQUALS(actor, task.GetSourceActor(), TEST_LOCATION);
END_TEST;
}
{
Actor actor = task.GetSourceActor();
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
// Manipulate the GenTextures behaviour, to identify different actors
std::vector<GLuint> ids;
- ids.push_back( 8 ); // 8 = actor1
- ids.push_back( 9 ); // 9 = actor2
- ids.push_back( 10 ); // 10 = actor3
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ ids.push_back(8); // 8 = actor1
+ ids.push_back(9); // 9 = actor2
+ ids.push_back(10); // 10 = actor3
+ application.GetGlAbstraction().SetNextTextureIds(ids);
- Texture img1 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor actor1 = CreateRenderableActor( img1 );
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- application.GetScene().Add( actor1 );
+ Texture img1 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor1 = CreateRenderableActor(img1);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ application.GetScene().Add(actor1);
// Update & Render actor1
application.SendNotification();
application.Render();
// Check that the actor1 was rendered
- const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures( GL_TEXTURE0 );
- DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 0 ), TEST_LOCATION );
+ const std::vector<GLuint>& boundTextures = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE0);
+ DALI_TEST_GREATER(boundTextures.size(), static_cast<std::vector<GLuint>::size_type>(0), TEST_LOCATION);
- if ( boundTextures.size() )
+ if(boundTextures.size())
{
int c = 0;
- DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
- if( boundTextures.size() > 1 )
+ DALI_TEST_EQUALS(boundTextures[c++], 8u /*unique to actor1*/, TEST_LOCATION);
+ if(boundTextures.size() > 1)
{
- DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[c++], 8u /*unique to actor1*/, TEST_LOCATION);
}
}
- Texture img2 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
+ Texture img2 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
- Actor actor2 = CreateRenderableActor( img2 );
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
+ Actor actor2 = CreateRenderableActor(img2);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
// Force actor2 to be rendered before actor1
Layer layer = Layer::New();
- application.GetScene().Add( layer );
- layer.Add( actor2 );
+ application.GetScene().Add(layer);
+ layer.Add(actor2);
layer.LowerToBottom();
// Update & Render
application.Render();
// Check that the actors were rendered
- DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 1 ), TEST_LOCATION );
+ DALI_TEST_GREATER(boundTextures.size(), static_cast<std::vector<GLuint>::size_type>(1), TEST_LOCATION);
- if ( boundTextures.size() )
+ if(boundTextures.size())
{
int c = 0;
- DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor2*/, TEST_LOCATION );
- if( boundTextures.size() > 2 )
+ DALI_TEST_EQUALS(boundTextures[c++], 9u /*unique to actor2*/, TEST_LOCATION);
+ if(boundTextures.size() > 2)
{
- DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor1*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[c++], 9u /*unique to actor1*/, TEST_LOCATION);
}
- DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[c++], 8u /*unique to actor1*/, TEST_LOCATION);
}
- Texture img3 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor actor3 = CreateRenderableActor( img3 );
- actor3.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
+ Texture img3 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor3 = CreateRenderableActor(img3);
+ actor3.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
// Force actor3 to be rendered before actor2
layer = Layer::New();
- application.GetScene().Add( layer );
- layer.Add( actor3 );
+ application.GetScene().Add(layer);
+ layer.Add(actor3);
layer.LowerToBottom();
// Update & Render all actors
application.Render();
// Check that the actors were rendered
- DALI_TEST_GREATER( boundTextures.size(), static_cast<std::vector<GLuint>::size_type>( 2 ), TEST_LOCATION );
+ DALI_TEST_GREATER(boundTextures.size(), static_cast<std::vector<GLuint>::size_type>(2), TEST_LOCATION);
- if ( boundTextures.size() )
+ if(boundTextures.size())
{
int c = 0;
- DALI_TEST_EQUALS( boundTextures[c++], 10u/*unique to actor3*/, TEST_LOCATION );
- if( boundTextures.size() > 3 )
+ DALI_TEST_EQUALS(boundTextures[c++], 10u /*unique to actor3*/, TEST_LOCATION);
+ if(boundTextures.size() > 3)
{
- DALI_TEST_EQUALS( boundTextures[c++], 10u/*unique to actor2*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[c++], 10u /*unique to actor2*/, TEST_LOCATION);
}
- DALI_TEST_EQUALS( boundTextures[c++], 9u/*unique to actor2*/, TEST_LOCATION );
- DALI_TEST_EQUALS( boundTextures[c++], 8u/*unique to actor1*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[c++], 9u /*unique to actor2*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(boundTextures[c++], 8u /*unique to actor1*/, TEST_LOCATION);
}
// Both actors are now connected to the root node
// Setup 2 render-tasks - the first will render from the root-node, and the second from actor2
// Not exclusive is the default
- RenderTask task1 = taskList.GetTask( 0u );
- DALI_TEST_CHECK( false == task1.IsExclusive() );
+ RenderTask task1 = taskList.GetTask(0u);
+ DALI_TEST_CHECK(false == task1.IsExclusive());
RenderTask task2 = taskList.CreateTask();
- DALI_TEST_CHECK( false == task2.IsExclusive() );
- task2.SetSourceActor( actor2 );
+ DALI_TEST_CHECK(false == task2.IsExclusive());
+ task2.SetSourceActor(actor2);
// Task1 should render all actors, and task 2 should render only actor2
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( boundTextures.size(), 4u, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures.size(), 4u, TEST_LOCATION);
- if ( boundTextures.size() == 4 )
+ if(boundTextures.size() == 4)
{
// Test that task 1 renders actor3, then actor2 & then actor1
- DALI_TEST_CHECK( boundTextures[0] == 10u );
- DALI_TEST_CHECK( boundTextures[1] == 9u );
- DALI_TEST_CHECK( boundTextures[2] == 8u );
+ DALI_TEST_CHECK(boundTextures[0] == 10u);
+ DALI_TEST_CHECK(boundTextures[1] == 9u);
+ DALI_TEST_CHECK(boundTextures[2] == 8u);
// Test that task 2 renders actor2
- DALI_TEST_EQUALS( boundTextures[3], 9u, TEST_LOCATION );
+ DALI_TEST_EQUALS(boundTextures[3], 9u, TEST_LOCATION);
}
// Make actor2 exclusive to task2
- task2.SetExclusive( true );
- DALI_TEST_CHECK( true == task2.IsExclusive() );
+ task2.SetExclusive(true);
+ DALI_TEST_CHECK(true == task2.IsExclusive());
// Task1 should render only actor1, and task 2 should render only actor2
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( boundTextures.size(), 3u, TEST_LOCATION );
- if ( boundTextures.size() == 3 )
+ DALI_TEST_EQUALS(boundTextures.size(), 3u, TEST_LOCATION);
+ if(boundTextures.size() == 3)
{
// Test that task 1 renders actor3 & actor1
- DALI_TEST_CHECK( boundTextures[0] == 10u );
- DALI_TEST_CHECK( boundTextures[1] == 8u );
+ DALI_TEST_CHECK(boundTextures[0] == 10u);
+ DALI_TEST_CHECK(boundTextures[1] == 8u);
// Test that task 2 renders actor2
- DALI_TEST_CHECK( boundTextures[2] == 9u );
+ DALI_TEST_CHECK(boundTextures[2] == 9u);
}
// Create a renderable actor and replace the source actor in task2
auto actor4 = CreateRenderableActor();
- task2.SetSourceActor( actor3 );
- DALI_TEST_EQUALS( actor3, task2.GetSourceActor(), TEST_LOCATION );
+ task2.SetSourceActor(actor3);
+ DALI_TEST_EQUALS(actor3, task2.GetSourceActor(), TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::SetExclusive() Check that changing from exclusive to not-exclusive works");
std::vector<GLuint> ids;
- ids.push_back( 8 ); // 8 = actor1
- application.GetGlAbstraction().SetNextTextureIds( ids );
+ ids.push_back(8); // 8 = actor1
+ application.GetGlAbstraction().SetNextTextureIds(ids);
- Texture img1 = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1 );
- Actor actor1 = CreateRenderableActor( img1 );
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 1.0f, 1.0f ) );
- application.GetScene().Add( actor1 );
+ Texture img1 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 1, 1);
+ Actor actor1 = CreateRenderableActor(img1);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(1.0f, 1.0f));
+ application.GetScene().Add(actor1);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
+ RenderTask task = taskList.CreateTask();
- task.SetSourceActor( actor1 );
+ task.SetSourceActor(actor1);
task.SetExclusive(true); // Actor should only render once
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Enable(true);
// Update & Render actor1
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
// Set task to non-exclusive - actor1 should render twice:
drawTrace.Reset();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 2, TEST_LOCATION);
END_TEST;
}
{
task.SetExclusive(true);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Not exclusive is the default
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( false == task.IsExclusive() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(false == task.IsExclusive());
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( false == newTask.IsExclusive() );
+ DALI_TEST_CHECK(false == newTask.IsExclusive());
END_TEST;
}
// Not exclusive is the default
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_EQUALS( newTask.IsExclusive(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(newTask.IsExclusive(), false, TEST_LOCATION);
newTask.SetExclusive(true);
- DALI_TEST_EQUALS( newTask.IsExclusive(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(newTask.IsExclusive(), true, TEST_LOCATION);
END_TEST;
}
try
{
bool x = task.IsExclusive();
- (void) x;
+ (void)x;
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Input is enabled by default
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( true == task.GetInputEnabled() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(true == task.GetInputEnabled());
- task.SetInputEnabled( false );
- DALI_TEST_CHECK( false == task.GetInputEnabled() );
+ task.SetInputEnabled(false);
+ DALI_TEST_CHECK(false == task.GetInputEnabled());
- task.SetInputEnabled( true );
- DALI_TEST_CHECK( true == task.GetInputEnabled() );
+ task.SetInputEnabled(true);
+ DALI_TEST_CHECK(true == task.GetInputEnabled());
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// Input is enabled by default
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( true, task.GetInputEnabled(), TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(true, task.GetInputEnabled(), TEST_LOCATION);
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_EQUALS( true, newTask.GetInputEnabled(), TEST_LOCATION );
+ DALI_TEST_EQUALS(true, newTask.GetInputEnabled(), TEST_LOCATION);
newTask.SetInputEnabled(false);
- DALI_TEST_EQUALS( false, newTask.GetInputEnabled(), TEST_LOCATION );
+ DALI_TEST_EQUALS(false, newTask.GetInputEnabled(), TEST_LOCATION);
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor defaultCameraActor = task.GetCameraActor();
- DALI_TEST_CHECK( defaultCameraActor );
+ DALI_TEST_CHECK(defaultCameraActor);
CameraActor newCameraActor = CameraActor::New();
- DALI_TEST_CHECK( newCameraActor );
+ DALI_TEST_CHECK(newCameraActor);
- task.SetCameraActor( newCameraActor );
- DALI_TEST_CHECK( task.GetCameraActor() != defaultCameraActor );
- DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
+ task.SetCameraActor(newCameraActor);
+ DALI_TEST_CHECK(task.GetCameraActor() != defaultCameraActor);
+ DALI_TEST_EQUALS(task.GetCameraActor(), newCameraActor, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskSetCameraActorN(void)
{
TestApplication application;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Actor actor = task.GetCameraActor();
- DALI_TEST_CHECK( actor );
+ DALI_TEST_CHECK(actor);
CameraActor cameraActor;
- task.SetCameraActor( cameraActor );
- DALI_TEST_EQUALS( (bool)task.GetCameraActor(), false, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCameraActor(), cameraActor, TEST_LOCATION );
+ task.SetCameraActor(cameraActor);
+ DALI_TEST_EQUALS((bool)task.GetCameraActor(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCameraActor(), cameraActor, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Testing RenderTask::SetCameraActor - Set a camera actor and destroy the camera actor" );
+ tet_infoline("Testing RenderTask::SetCameraActor - Set a camera actor and destroy the camera actor");
- Integration::Scene stage = application.GetScene();
- RenderTaskList taskList = stage.GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ Integration::Scene stage = application.GetScene();
+ RenderTaskList taskList = stage.GetRenderTaskList();
+ RenderTask task = taskList.GetTask(0u);
CameraActor newCameraActor = CameraActor::New();
- task.SetCameraActor( newCameraActor );
+ task.SetCameraActor(newCameraActor);
- DALI_TEST_EQUALS( task.GetCameraActor(), newCameraActor, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCameraActor(), newCameraActor, TEST_LOCATION);
// Destroy the camera actor
newCameraActor.Reset();
CameraActor camera = task.GetCameraActor();
- DALI_TEST_CHECK( !camera ); // The camera actor should be an empty handle.
+ DALI_TEST_CHECK(!camera); // The camera actor should be an empty handle.
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
CameraActor actor = task.GetCameraActor();
- DALI_TEST_CHECK( actor );
- DALI_TEST_EQUALS( actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION );
- DALI_TEST_GREATER( actor.GetFieldOfView(), 0.0f, TEST_LOCATION );
+ DALI_TEST_CHECK(actor);
+ DALI_TEST_EQUALS(actor.GetProjectionMode(), Dali::Camera::PERSPECTIVE_PROJECTION, TEST_LOCATION);
+ DALI_TEST_GREATER(actor.GetFieldOfView(), 0.0f, TEST_LOCATION);
END_TEST;
}
{
Actor actor = task.GetCameraActor();
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- FrameBuffer newFrameBuffer = FrameBuffer::New( 128u, 128u, FrameBuffer::Attachment::NONE );
- task.SetFrameBuffer( newFrameBuffer );
- DALI_TEST_CHECK( task.GetFrameBuffer() == newFrameBuffer );
+ FrameBuffer newFrameBuffer = FrameBuffer::New(128u, 128u, FrameBuffer::Attachment::NONE);
+ task.SetFrameBuffer(newFrameBuffer);
+ DALI_TEST_CHECK(task.GetFrameBuffer() == newFrameBuffer);
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
FrameBuffer newFrameBuffer; // Empty handle
- task.SetFrameBuffer( newFrameBuffer );
- DALI_TEST_EQUALS( (bool)task.GetFrameBuffer(), false, TEST_LOCATION );
+ task.SetFrameBuffer(newFrameBuffer);
+ DALI_TEST_EQUALS((bool)task.GetFrameBuffer(), false, TEST_LOCATION);
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- FrameBuffer newFrameBuffer = FrameBuffer::New( 1u, 1u, FrameBuffer::Attachment::NONE );
- task.SetFrameBuffer( newFrameBuffer );
- DALI_TEST_CHECK( task.GetFrameBuffer() == newFrameBuffer );
+ FrameBuffer newFrameBuffer = FrameBuffer::New(1u, 1u, FrameBuffer::Attachment::NONE);
+ task.SetFrameBuffer(newFrameBuffer);
+ DALI_TEST_CHECK(task.GetFrameBuffer() == newFrameBuffer);
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
// By default render-tasks do not render off-screen
FrameBuffer frameBuffer = task.GetFrameBuffer();
- DALI_TEST_CHECK( !frameBuffer );
+ DALI_TEST_CHECK(!frameBuffer);
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
+ task.SetScreenToFrameBufferFunction(TestScreenToFrameBufferFunction);
- Vector2 coordinates( 5, 10 );
- Vector2 convertedCoordinates( 6, 12 ); // + Vector(1, 2)
+ Vector2 coordinates(5, 10);
+ Vector2 convertedCoordinates(6, 12); // + Vector(1, 2)
RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( func( coordinates ) );
- DALI_TEST_CHECK( coordinates == convertedCoordinates );
+ DALI_TEST_CHECK(func(coordinates));
+ DALI_TEST_CHECK(coordinates == convertedCoordinates);
- task.SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+ task.SetScreenToFrameBufferFunction(RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION);
func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( func( coordinates ) );
+ DALI_TEST_CHECK(func(coordinates));
- task.SetScreenToFrameBufferFunction( RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION );
+ task.SetScreenToFrameBufferFunction(RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION);
func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( ! func( coordinates ) );
+ DALI_TEST_CHECK(!func(coordinates));
END_TEST;
}
RenderTask task; // Empty handle
try
{
- task.SetScreenToFrameBufferFunction( TestScreenToFrameBufferFunction );
+ task.SetScreenToFrameBufferFunction(TestScreenToFrameBufferFunction);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
- Vector2 originalCoordinates( 5, 10 );
- Vector2 coordinates( 5, 10 );
+ Vector2 originalCoordinates(5, 10);
+ Vector2 coordinates(5, 10);
RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
- DALI_TEST_CHECK( !func( coordinates ) ); // conversion should fail by default
- DALI_TEST_CHECK( coordinates == originalCoordinates ); // coordinates should not be modified
+ DALI_TEST_CHECK(!func(coordinates)); // conversion should fail by default
+ DALI_TEST_CHECK(coordinates == originalCoordinates); // coordinates should not be modified
END_TEST;
}
try
{
RenderTask::ScreenToFrameBufferFunction func = task.GetScreenToFrameBufferFunction();
- (void) func;
+ (void)func;
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorP(void)
{
TestApplication application;
tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor ");
- RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
- Actor mappingActor = Actor::New();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask renderTask = taskList.CreateTask();
+ Actor mappingActor = Actor::New();
renderTask.SetScreenToFrameBufferMappingActor(mappingActor);
- DALI_TEST_EQUALS( mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION );
+ DALI_TEST_EQUALS(mappingActor, renderTask.GetScreenToFrameBufferMappingActor(), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorN(void)
{
TestApplication application;
Actor mappingActor;
task.SetScreenToFrameBufferMappingActor(mappingActor);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
TestApplication application;
tet_infoline("Testing RenderTask::GetScreenToFrameBufferMappingActor with empty task handle");
- RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask renderTask = taskList.CreateTask();
- Actor actor;
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask renderTask = taskList.CreateTask();
+ Actor actor;
renderTask.SetScreenToFrameBufferMappingActor(actor);
- DALI_TEST_EQUALS( (bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
+ DALI_TEST_EQUALS((bool)renderTask.GetScreenToFrameBufferMappingActor(), false, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::GetViewport() on default task");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- Viewport viewport = task.GetViewport();
+ RenderTask task = taskList.GetTask(0u);
+ Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = application.GetScene().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
END_TEST;
}
tet_infoline("Testing RenderTask::GetViewport() on new task");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
- Viewport viewport = task.GetViewport();
+ RenderTask task = taskList.CreateTask();
+ Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = application.GetScene().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
END_TEST;
}
try
{
Viewport viewport = task.GetViewport();
- (void) viewport;
+ (void)viewport;
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskSetViewportP(void)
{
TestApplication application;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- Vector2 stageSize = application.GetScene().GetSize();
- Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
- task.SetViewport( newViewport );
+ RenderTask task = taskList.GetTask(0u);
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport newViewport(0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f);
+ task.SetViewport(newViewport);
// Update (viewport is a property)
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( task.GetViewport() == newViewport );
+ DALI_TEST_CHECK(task.GetViewport() == newViewport);
END_TEST;
}
RenderTask task;
try
{
- Vector2 stageSize = application.GetScene().GetSize();
- Viewport newViewport( 0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f );
- task.SetViewport( newViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport newViewport(0, 0, stageSize.width * 0.5f, stageSize.height * 0.5f);
+ task.SetViewport(newViewport);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskSetViewportPosition(void)
{
TestApplication application;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = application.GetScene().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
// 'Setter' test
Vector2 newPosition(25.0f, 50.0f);
- task.SetViewportPosition( newPosition );
+ task.SetViewportPosition(newPosition);
// Update (viewport is a property)
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Set by Property test
Vector2 newPosition2(32.0f, 32.0f);
- task.SetProperty( RenderTask::Property::VIEWPORT_POSITION, newPosition2 );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition, TEST_LOCATION ); // still the old position
+ task.SetProperty(RenderTask::Property::VIEWPORT_POSITION, newPosition2);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition, TEST_LOCATION); // still the old position
// Update
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition2, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
- Vector2 newPosition3(64.0f, 0.0f);
+ Vector2 newPosition3(64.0f, 0.0f);
Animation animation = Animation::New(1.0f);
- animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_POSITION ), newPosition3, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(task, RenderTask::Property::VIEWPORT_POSITION), newPosition3, AlphaFunction::LINEAR);
animation.Play();
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition2, TEST_LOCATION);
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Create another animation which animates by a certain value
- const Vector2 newPosition4( 75.0f, 45.0f );
- const Vector2 relativePosition( newPosition4 - newPosition3 );
- animation = Animation::New( 1.0f );
- animation.AnimateBy( Property( task, RenderTask::Property::VIEWPORT_POSITION ), relativePosition );
+ const Vector2 newPosition4(75.0f, 45.0f);
+ const Vector2 relativePosition(newPosition4 - newPosition3);
+ animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(task, RenderTask::Property::VIEWPORT_POSITION), relativePosition);
animation.Play();
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition3, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition3, TEST_LOCATION);
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentViewportPosition(), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_POSITION ), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportPosition(), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_POSITION), newPosition4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
Viewport viewport = task.GetViewport();
// By default the viewport should match the stage width/height
- Vector2 stageSize = application.GetScene().GetSize();
- Viewport expectedViewport( 0, 0, stageSize.width, stageSize.height );
- DALI_TEST_CHECK( viewport == expectedViewport );
+ Vector2 stageSize = application.GetScene().GetSize();
+ Viewport expectedViewport(0, 0, stageSize.width, stageSize.height);
+ DALI_TEST_CHECK(viewport == expectedViewport);
Vector2 newSize(128.0f, 64.0f);
- task.SetViewportSize( newSize );
+ task.SetViewportSize(newSize);
// Update (viewport is a property)
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Set by Property test
Vector2 newSize2(50.0f, 50.0f);
- task.SetProperty( RenderTask::Property::VIEWPORT_SIZE, newSize2 );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize, TEST_LOCATION ); // still the old position
+ task.SetProperty(RenderTask::Property::VIEWPORT_SIZE, newSize2);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize, TEST_LOCATION); // still the old position
// Update
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize2, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
- Vector2 newSize3(10.0f, 10.0f);
+ Vector2 newSize3(10.0f, 10.0f);
Animation animation = Animation::New(1.0f);
- animation.AnimateTo( Property( task, RenderTask::Property::VIEWPORT_SIZE ), newSize3, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(task, RenderTask::Property::VIEWPORT_SIZE), newSize3, AlphaFunction::LINEAR);
animation.Play();
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize2, TEST_LOCATION);
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Create another animation which animates by a certain value
- const Vector2 newSize4( 75.0f, 45.0f );
- const Vector2 relativeSize( newSize4 - newSize3 );
- animation = Animation::New( 1.0f );
- animation.AnimateBy( Property( task, RenderTask::Property::VIEWPORT_SIZE ), relativeSize );
+ const Vector2 newSize4(75.0f, 45.0f);
+ const Vector2 relativeSize(newSize4 - newSize3);
+ animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(task, RenderTask::Property::VIEWPORT_SIZE), relativeSize);
animation.Play();
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize3, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize3, TEST_LOCATION);
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentViewportSize(), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector2 >( RenderTask::Property::VIEWPORT_SIZE ), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentViewportSize(), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector2>(RenderTask::Property::VIEWPORT_SIZE), newSize4, Math::MACHINE_EPSILON_1, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::SetClearColor()");
- Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
- Vector4 testColor2( 5.0f, 6.0f, 7.0f, 8.0f );
+ Vector4 testColor(1.0f, 2.0f, 3.0f, 4.0f);
+ Vector4 testColor2(5.0f, 6.0f, 7.0f, 8.0f);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( task.GetClearColor() != testColor );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task.GetClearColor() != testColor);
- task.SetClearColor( testColor );
+ task.SetClearColor(testColor);
// Wait a frame.
Wait(application);
- DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor, TEST_LOCATION);
- task.SetProperty( RenderTask::Property::CLEAR_COLOR, testColor2 );
- DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor, TEST_LOCATION ); // still the old color
+ task.SetProperty(RenderTask::Property::CLEAR_COLOR, testColor2);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor, TEST_LOCATION); // still the old color
// Wait a frame.
Wait(application);
- DALI_TEST_EQUALS( task.GetClearColor(), testColor2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
- Vector4 newColor3(10.0f, 10.0f, 20.0f, 30.0f);
+ Vector4 newColor3(10.0f, 10.0f, 20.0f, 30.0f);
Animation animation = Animation::New(1.0f);
- animation.AnimateTo( Property( task, RenderTask::Property::CLEAR_COLOR ), newColor3, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(task, RenderTask::Property::CLEAR_COLOR), newColor3, AlphaFunction::LINEAR);
animation.Play();
- DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), testColor2, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), testColor2, TEST_LOCATION);
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Create another animation which animates by a certain value
- const Vector4 newColor4( 0.45f, 0.35f, 0.25f, 0.1f );
- const Vector4 relativeColor( newColor4 - newColor3 );
- animation = Animation::New( 1.0f );
- animation.AnimateBy( Property( task, RenderTask::Property::CLEAR_COLOR ), relativeColor );
+ const Vector4 newColor4(0.45f, 0.35f, 0.25f, 0.1f);
+ const Vector4 relativeColor(newColor4 - newColor3);
+ animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(task, RenderTask::Property::CLEAR_COLOR), relativeColor);
animation.Play();
- DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor3, Math::MACHINE_EPSILON_10, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor3, Math::MACHINE_EPSILON_10, TEST_LOCATION);
// Perform 1000ms worth of updates at which point animation should have completed.
Wait(application, 1000);
- DALI_TEST_EQUALS( task.GetCurrentProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
- DALI_TEST_EQUALS( task.GetProperty< Vector4 >( RenderTask::Property::CLEAR_COLOR ), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCurrentProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION);
+ DALI_TEST_EQUALS(task.GetProperty<Vector4>(RenderTask::Property::CLEAR_COLOR), newColor4, Math::MACHINE_EPSILON_10, TEST_LOCATION);
END_TEST;
}
RenderTask task;
try
{
- task.SetClearColor( Vector4::ZERO );
+ task.SetClearColor(Vector4::ZERO);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::GetClearColor()");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(task.GetClearColor(), RenderTask::DEFAULT_CLEAR_COLOR, TEST_LOCATION);
END_TEST;
}
try
{
Vector4 color = task.GetClearColor();
- (void) color;
+ (void)color;
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( task.GetClearEnabled() ); // defaults to true
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task.GetClearEnabled()); // defaults to true
- task.SetClearEnabled( false );
- DALI_TEST_EQUALS( task.GetClearEnabled(), false, TEST_LOCATION );
+ task.SetClearEnabled(false);
+ DALI_TEST_EQUALS(task.GetClearEnabled(), false, TEST_LOCATION);
- task.SetClearEnabled( true );
- DALI_TEST_EQUALS( task.GetClearEnabled(), true, TEST_LOCATION );
+ task.SetClearEnabled(true);
+ DALI_TEST_EQUALS(task.GetClearEnabled(), true, TEST_LOCATION);
END_TEST;
}
{
task.SetClearEnabled(true);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( task.GetClearEnabled() ); // defaults to true
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task.GetClearEnabled()); // defaults to true
END_TEST;
}
-
int UtcDaliRenderTaskGetClearEnabledN(void)
{
TestApplication application;
try
{
bool x = task.GetClearEnabled();
- (void) x;
+ (void)x;
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::SetCullMode()");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(task.GetCullMode(), true, TEST_LOCATION);
- task.SetCullMode( false );
+ task.SetCullMode(false);
- DALI_TEST_EQUALS( task.GetCullMode(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetCullMode(), false, TEST_LOCATION);
END_TEST;
}
RenderTask task;
try
{
- task.SetCullMode( false );
+ task.SetCullMode(false);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
tet_infoline("Testing RenderTask::GetCullMode()");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_EQUALS( task.GetCullMode(), true, TEST_LOCATION );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_EQUALS(task.GetCullMode(), true, TEST_LOCATION);
END_TEST;
}
try
{
bool x = task.GetCullMode();
- (void) x;
+ (void)x;
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "RenderTask handle is empty", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliRenderTaskSetRefreshRate(void)
{
TestApplication application;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// By default tasks will be processed every frame
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == task.GetRefreshRate());
- task.SetRefreshRate( 2u ); // every-other frame
- DALI_TEST_CHECK( 2u == task.GetRefreshRate() );
+ task.SetRefreshRate(2u); // every-other frame
+ DALI_TEST_CHECK(2u == task.GetRefreshRate());
- task.SetRefreshRate( RenderTask::REFRESH_ALWAYS );
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
+ task.SetRefreshRate(RenderTask::REFRESH_ALWAYS);
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == task.GetRefreshRate());
END_TEST;
}
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
// By default tasks will be processed every frame
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == task.GetRefreshRate() );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == task.GetRefreshRate());
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate() );
+ DALI_TEST_CHECK(RenderTask::REFRESH_ALWAYS == newTask.GetRefreshRate());
END_TEST;
}
tet_infoline("Testing RenderTask::SignalFinished()");
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
CameraActor offscreenCameraActor = CameraActor::New();
- application.GetScene().Add( offscreenCameraActor );
+ application.GetScene().Add(offscreenCameraActor);
- Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10 );
- Actor rootActor = CreateRenderableActor( image );
- rootActor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
- application.GetScene().Add( rootActor );
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10);
+ Actor rootActor = CreateRenderableActor(image);
+ rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ application.GetScene().Add(rootActor);
- RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
- Texture frameBufferTexture = Texture::New( *testNativeImagePtr );
- FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(),frameBufferTexture.GetHeight());
+ Texture frameBufferTexture = Texture::New(*testNativeImagePtr);
+ FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight());
frameBuffer.AttachColorTexture(frameBufferTexture);
RenderTask newTask = taskList.CreateTask();
- newTask.SetCameraActor( offscreenCameraActor );
- newTask.SetSourceActor( rootActor );
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
- newTask.SetFrameBuffer( frameBuffer );
- newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
-
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ newTask.SetCameraActor(offscreenCameraActor);
+ newTask.SetSourceActor(rootActor);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, true);
+
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
// Flush the queue and render.
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ DALI_TEST_CHECK(lastSyncObj != NULL);
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( ! finished );
+ DALI_TEST_CHECK(!finished);
- sync.SetObjectSynced( lastSyncObj, true );
+ sync.SetObjectSynced(lastSyncObj, true);
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( finished );
+ DALI_TEST_CHECK(finished);
- DALI_TEST_EQUALS( application.GetUpdateStatus(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(application.GetUpdateStatus(), 0, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskContinuous01(void)
{
TestApplication application;
tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not staged)\nPOST:continuous renders, no Finished signal");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected, KeepUpdating
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, false, __LINE__));
application.GetPlatform().ClearReadyResources();
// ADD SOURCE ACTOR TO STAGE - expect continuous renders to start, no finished signal
application.SendNotification();
// CONTINUE PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
-
int UtcDaliRenderTaskContinuous02(void)
{
TestApplication application;
tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (source actor not visible)\nPOST:continuous renders, no Finished signal");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- secondRootActor.SetProperty( Actor::Property::VISIBLE,false);
+ secondRootActor.SetProperty(Actor::Property::VISIBLE, false);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected, KeepUpdating
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, false, __LINE__));
application.GetPlatform().ClearReadyResources();
// MAKE SOURCE ACTOR VISIBLE - expect continuous renders to start, no finished signal
- secondRootActor.SetProperty( Actor::Property::VISIBLE,true);
+ secondRootActor.SetProperty(Actor::Property::VISIBLE, true);
application.SendNotification();
// CONTINUE PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
tet_infoline("Testing RenderTask Render Continuous using loading image\nPRE: render task not ready (camera actor not staged)\nPOST:continuous renders, no Finished signal");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, false, __LINE__));
application.GetPlatform().ClearReadyResources();
// ADD CAMERA ACTOR TO STAGE - expect continuous renders to start, no finished signal
- application.GetScene().Add( offscreenCameraActor );
+ application.GetScene().Add(offscreenCameraActor);
application.SendNotification();
// CONTINUE PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
-
int UtcDaliRenderTaskContinuous04(void)
{
TestApplication application;
tet_infoline("Testing RenderTask Render Continuous using loaded image");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
tet_infoline("Testing RenderTask Render Once GlSync, using loaded image");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
- sync.SetObjectSynced( lastSyncObj, true );
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Shader shader = CreateShader();
- Texture image = CreateTexture();
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, shader);
- renderer.SetTextures( textureSet );
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
- sync.SetObjectSynced( lastSyncObj, true );
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
- END_TEST;
+ END_TEST;
}
int UtcDaliRenderTaskOnce03(void)
tet_infoline("Testing RenderTask Render Once GlSync, using loaded image. Switch from render always after ready to render once\n");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
- sync.SetObjectSynced( lastSyncObj, true );
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
-
int UtcDaliRenderTaskOnce04(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n"
- "Switch from render always after ready to render once\n"
- );
+ tet_infoline(
+ "Testing RenderTask Render Once GlSync, using Mesh which accesses texture through sampler with loaded image.\n"
+ "Switch from render always after ready to render once\n");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
- TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
+ TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Shader shader = CreateShader();
- Texture image = CreateTexture();
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, shader);
- renderer.SetTextures( textureSet );
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, true);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
- sync.SetObjectSynced( lastSyncObj, true );
+ DALI_TEST_CHECK(lastSyncObj != NULL);
+ sync.SetObjectSynced(lastSyncObj, true);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
tet_infoline("Testing RenderTask Render Once, \nPRE: Resources ready\nPOST: Finished signal sent once only");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loaded image.\n"
- "PRE: Resources ready\nPOST: Finished signal sent once only");
+ tet_infoline(
+ "Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loaded image.\n"
+ "PRE: Resources ready\nPOST: Finished signal sent once only");
// SETUP AN OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Shader shader = CreateShader();
- Texture image = CreateTexture();
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, shader);
- renderer.SetTextures( textureSet );
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
application.GetPlatform().ClearReadyResources();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once, using loaded image. Switch from render always after ready to render once\n"
- "PRE: Render task ready, Image loaded\n"
- "POST: Finished signal sent only once");
+ tet_infoline(
+ "Testing RenderTask Render Once, using loaded image. Switch from render always after ready to render once\n"
+ "PRE: Render task ready, Image loaded\n"
+ "POST: Finished signal sent only once");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
END_TEST;
}
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
- "Switch from render always after ready to render once\n"
- "PRE: Render task ready, Image not loaded\n"
- "POST: Finished signal sent only once");
+ tet_infoline(
+ "Testing RenderTask Render Once, using Mesh which accesses texture through sampler with loading image.\n"
+ "Switch from render always after ready to render once\n"
+ "PRE: Render task ready, Image not loaded\n"
+ "POST: Finished signal sent only once");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Shader shader = CreateShader();
- Texture image = CreateTexture();
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = CreateShader();
+ Texture image = CreateTexture();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, shader);
- renderer.SetTextures( textureSet );
+ renderer.SetTextures(textureSet);
Actor secondRootActor = Actor::New();
secondRootActor.AddRenderer(renderer);
- secondRootActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ secondRootActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
application.GetScene().Add(secondRootActor);
-
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
- TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
+ TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
+ DALI_TEST_CHECK(lastSyncObj == NULL);
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
application.SendNotification(); // Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, finished, true, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, true, __LINE__));
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, finished, true, false, __LINE__));
lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj == NULL );
+ DALI_TEST_CHECK(lastSyncObj == NULL);
END_TEST;
}
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once\n"
- "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
- "PRE: resources failed to load\n"
- "POST: No finished signal sent.");
+ tet_infoline(
+ "Testing RenderTask Render Once\n"
+ "SetRefreshRate(ONCE), resource load failed, completes render task.\n"
+ "PRE: resources failed to load\n"
+ "POST: No finished signal sent.");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor secondRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(secondRootActor);
- RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, secondRootActor, RenderTask::REFRESH_ALWAYS, false);
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
application.SendNotification();
// START PROCESS/RENDER Input, Expected Input, Expected
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
// CHANGE TO RENDER ONCE,
newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, finished, false, false, __LINE__ ) );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, finished, false, false, __LINE__));
END_TEST;
}
-
-
int UtcDaliRenderTaskOnceChain01(void)
{
TestApplication application;
- tet_infoline("Testing RenderTask Render Once Chained render tasks\n"
- "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
- "PRE: resources ready\n"
- "POST: 2 finished signals sent.");
+ tet_infoline(
+ "Testing RenderTask Render Once Chained render tasks\n"
+ "SetRefreshRate(ONCE), resource load completes, both render tasks render.\n"
+ "PRE: resources ready\n"
+ "POST: 2 finished signals sent.");
// SETUP A CONTINUOUS OFFSCREEN RENDER TASK
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TraceCallStack& drawTrace = application.GetGlAbstraction().GetDrawTrace();
drawTrace.Enable(true);
Actor defaultRootActor = Actor::New(); // Root for default RT
- application.GetScene().Add( defaultRootActor );
+ application.GetScene().Add(defaultRootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
Actor firstRootActor = CreateRenderableActorSuccess(application, "aFile.jpg");
application.GetScene().Add(firstRootActor);
// first render task
- RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
- bool firstFinished = false;
- RenderTaskFinished renderTask1Finished( firstFinished );
- firstTask.FinishedSignal().Connect( &application, renderTask1Finished );
+ RenderTask firstTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, firstRootActor, RenderTask::REFRESH_ONCE, false);
+ bool firstFinished = false;
+ RenderTaskFinished renderTask1Finished(firstFinished);
+ firstTask.FinishedSignal().Connect(&application, renderTask1Finished);
// Second render task
- FrameBuffer fbo = firstTask.GetFrameBuffer();
- Actor secondRootActor = CreateRenderableActor( fbo.GetColorTexture() );
+ FrameBuffer fbo = firstTask.GetFrameBuffer();
+ Actor secondRootActor = CreateRenderableActor(fbo.GetColorTexture());
application.GetScene().Add(secondRootActor);
- RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
- bool secondFinished = false;
- RenderTaskFinished renderTask2Finished( secondFinished );
- secondTask.FinishedSignal().Connect( &application, renderTask2Finished );
+ RenderTask secondTask = CreateRenderTask(application, offscreenCameraActor, defaultRootActor, secondRootActor, RenderTask::REFRESH_ONCE, false);
+ bool secondFinished = false;
+ RenderTaskFinished renderTask2Finished(secondFinished);
+ secondTask.FinishedSignal().Connect(&application, renderTask2Finished);
application.SendNotification();
//Both render tasks are executed.
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, true, firstFinished, false, true, __LINE__ ) );
- DALI_TEST_CHECK( firstFinished == false );
- DALI_TEST_CHECK( secondFinished == false );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, true, firstFinished, false, true, __LINE__));
+ DALI_TEST_CHECK(firstFinished == false);
+ DALI_TEST_CHECK(secondFinished == false);
//Nothing else to render and both render task should have finished now
- DALI_TEST_CHECK( UpdateRender(application, drawTrace, false, firstFinished, true, false, __LINE__ ) );
- DALI_TEST_CHECK( firstFinished == true );
- DALI_TEST_CHECK( secondFinished == true );
+ DALI_TEST_CHECK(UpdateRender(application, drawTrace, false, firstFinished, true, false, __LINE__));
+ DALI_TEST_CHECK(firstFinished == true);
+ DALI_TEST_CHECK(secondFinished == true);
END_TEST;
}
RenderTask task = application.GetScene().GetRenderTaskList().CreateTask();
Property::IndexContainer indices;
- task.GetPropertyIndices( indices );
- DALI_TEST_CHECK( indices.Size() );
- DALI_TEST_EQUALS( indices.Size(), task.GetPropertyCount(), TEST_LOCATION );
+ task.GetPropertyIndices(indices);
+ DALI_TEST_CHECK(indices.Size());
+ DALI_TEST_EQUALS(indices.Size(), task.GetPropertyCount(), TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing RenderTask::FinishInvisibleSourceActor()");
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TestGlSyncAbstraction& sync = application.GetGlSyncAbstraction();
CameraActor offscreenCameraActor = CameraActor::New();
- application.GetScene().Add( offscreenCameraActor );
+ application.GetScene().Add(offscreenCameraActor);
- Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10 );
- Actor rootActor = CreateRenderableActor( image );
- rootActor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
- rootActor.SetProperty( Actor::Property::VISIBLE,false);
- application.GetScene().Add( rootActor );
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10);
+ Actor rootActor = CreateRenderableActor(image);
+ rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ rootActor.SetProperty(Actor::Property::VISIBLE, false);
+ application.GetScene().Add(rootActor);
- RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
NativeImageInterfacePtr testNativeImagePtr = TestNativeImage::New(10, 10);
- Texture frameBufferTexture = Texture::New( *testNativeImagePtr );
- FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight());
+ Texture frameBufferTexture = Texture::New(*testNativeImagePtr);
+ FrameBuffer frameBuffer = FrameBuffer::New(frameBufferTexture.GetWidth(), frameBufferTexture.GetHeight());
frameBuffer.AttachColorTexture(frameBufferTexture);
// Flush all outstanding messages
application.Render();
RenderTask newTask = taskList.CreateTask();
- newTask.SetCameraActor( offscreenCameraActor );
- newTask.SetSourceActor( rootActor );
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
- newTask.SetFrameBuffer( frameBuffer );
- newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
+ newTask.SetCameraActor(offscreenCameraActor);
+ newTask.SetSourceActor(rootActor);
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
+ newTask.SetFrameBuffer(frameBuffer);
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, true);
// Framebuffer doesn't actually get created until Connected, i.e. by previous line
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
// Flush the queue and render.
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
Integration::GlSyncAbstraction::SyncObject* lastSyncObj = sync.GetLastSyncObject();
- DALI_TEST_CHECK( lastSyncObj != NULL );
+ DALI_TEST_CHECK(lastSyncObj != NULL);
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
application.Render();
- DALI_TEST_EQUALS( (Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION );
+ DALI_TEST_EQUALS((Integration::KeepUpdating::Reasons)(application.GetUpdateStatus() & Integration::KeepUpdating::RENDER_TASK_SYNC), Integration::KeepUpdating::RENDER_TASK_SYNC, TEST_LOCATION);
application.SendNotification();
- DALI_TEST_CHECK( ! finished );
+ DALI_TEST_CHECK(!finished);
- sync.SetObjectSynced( lastSyncObj, true );
+ sync.SetObjectSynced(lastSyncObj, true);
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( !finished );
+ DALI_TEST_CHECK(!finished);
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( finished );
+ DALI_TEST_CHECK(finished);
finished = false;
application.Render(); // Double check no more finished signal
application.SendNotification();
- DALI_TEST_CHECK( ! finished );
+ DALI_TEST_CHECK(!finished);
END_TEST;
}
Integration::Scene stage = application.GetScene();
- Texture image = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10 );
- Actor rootActor = CreateRenderableActor( image );
- rootActor.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
- stage.Add( rootActor );
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 10, 10);
+ Actor rootActor = CreateRenderableActor(image);
+ rootActor.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ stage.Add(rootActor);
- Actor actorWithMissingImage = CreateRenderableActor( Texture() );
- actorWithMissingImage.SetProperty( Actor::Property::SIZE, Vector2( 10.0f, 10.0f ) );
- stage.Add( actorWithMissingImage );
+ Actor actorWithMissingImage = CreateRenderableActor(Texture());
+ actorWithMissingImage.SetProperty(Actor::Property::SIZE, Vector2(10.0f, 10.0f));
+ stage.Add(actorWithMissingImage);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask newTask = taskList.CreateTask();
- newTask.SetInputEnabled( false );
- newTask.SetClearColor( Vector4( 0.f, 0.f, 0.f, 0.f ) );
- newTask.SetClearEnabled( true );
- newTask.SetExclusive( true );
- newTask.SetRefreshRate( RenderTask::REFRESH_ONCE );
+ RenderTask newTask = taskList.CreateTask();
+ newTask.SetInputEnabled(false);
+ newTask.SetClearColor(Vector4(0.f, 0.f, 0.f, 0.f));
+ newTask.SetClearEnabled(true);
+ newTask.SetExclusive(true);
+ newTask.SetRefreshRate(RenderTask::REFRESH_ONCE);
- bool finished = false;
- RenderTaskFinished renderTaskFinished( finished );
- newTask.FinishedSignal().Connect( &application, renderTaskFinished );
+ bool finished = false;
+ RenderTaskFinished renderTaskFinished(finished);
+ newTask.FinishedSignal().Connect(&application, renderTaskFinished);
// 1 render to process render task, then 1 before finished msg is sent from update to the event thread.
application.SendNotification();
application.Render();
application.SendNotification();
- DALI_TEST_CHECK( finished );
+ DALI_TEST_CHECK(finished);
END_TEST;
}
int UtcDaliRenderTaskWorldToViewport(void)
{
- TestApplication application( 400u, 400u ); // square surface
+ TestApplication application(400u, 400u); // square surface
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0));
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.5) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.5) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.5));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.5));
application.GetScene().Add(actor);
application.Render();
application.SendNotification();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
CameraActor camera = task.GetCameraActor();
float screenX = 0.0;
float screenY = 0.0;
- bool ok = task.WorldToViewport(actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), screenX, screenY);
+ bool ok = task.WorldToViewport(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), screenX, screenY);
DALI_TEST_CHECK(ok == true);
- DALI_TEST_EQUALS(screenX, screenSize.x/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- DALI_TEST_EQUALS(screenY, screenSize.y/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenX, screenSize.x / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenY, screenSize.y / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- Actor actor2 = Actor::New();
+ Actor actor2 = Actor::New();
float actor2Size = 100.f;
- actor2.SetProperty( Actor::Property::SIZE, Vector2( actor2Size, actor2Size ) );
- actor2.SetProperty( Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0) );
- actor2.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.0) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.0) );
- application.GetScene().Add( actor2 );
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(actor2Size, actor2Size));
+ actor2.SetProperty(Actor::Property::POSITION, Vector3(0.0, 0.0, 0.0));
+ actor2.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0.5, 0.5, 0.0));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, Vector3(0.5, 0.5, 0.0));
+ application.GetScene().Add(actor2);
actor2.Add(actor);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, Vector3(0,0,0) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, Vector3(0, 0, 0));
application.SendNotification();
application.Render();
application.SendNotification();
- ok = task.WorldToViewport(actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION ), screenX, screenY);
+ ok = task.WorldToViewport(actor.GetCurrentProperty<Vector3>(Actor::Property::WORLD_POSITION), screenX, screenY);
DALI_TEST_CHECK(ok == true);
- DALI_TEST_EQUALS(screenX, screenSize.x/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
- DALI_TEST_EQUALS(screenY, screenSize.y/2 - actor2Size/2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenX, screenSize.x / 2 - actor2Size / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenY, screenSize.y / 2 - actor2Size / 2, Math::MACHINE_EPSILON_10000, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRenderTaskViewportToLocal(void)
{
TestApplication application;
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::POSITION, Vector2(10.0f, 10.0f));
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
application.GetScene().Add(actor);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
+ RenderTask task = taskList.GetTask(0u);
// flush the queue and render once
application.SendNotification();
float screenX = 50.0f;
float screenY = 50.0f;
- DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
+ DALI_TEST_CHECK(actor.ScreenToLocal(localX, localY, screenX, screenY));
- DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
+ DALI_TEST_CHECK(task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY));
DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
END_TEST;
-
}
int UtcDaliRenderTaskOffscreenViewportToLocal(void)
{
TestApplication application;
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::POSITION, Vector2( 10.0f, 10.0f ));
- application.GetScene().Add( actor );
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(10.0f, 10.0f));
+ application.GetScene().Add(actor);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.CreateTask();
+ RenderTask task = taskList.CreateTask();
FrameBuffer newFrameBuffer = FrameBuffer::New(10, 10);
- task.SetFrameBuffer( newFrameBuffer );
- task.SetSourceActor( actor );
- task.SetScreenToFrameBufferMappingActor( actor );
+ task.SetFrameBuffer(newFrameBuffer);
+ task.SetSourceActor(actor);
+ task.SetScreenToFrameBufferMappingActor(actor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
- task.SetCameraActor( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
+ task.SetCameraActor(offscreenCameraActor);
// flush the queue and render once
application.SendNotification();
float screenX = 50.0f;
float screenY = 50.0f;
- DALI_TEST_CHECK( actor.ScreenToLocal(localX, localY, screenX, screenY) );
+ DALI_TEST_CHECK(actor.ScreenToLocal(localX, localY, screenX, screenY));
- DALI_TEST_CHECK( task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY ) );
+ DALI_TEST_CHECK(task.ViewportToLocal(actor, screenX, screenY, rtLocalX, rtLocalY));
DALI_TEST_EQUALS(localX, rtLocalX, 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(localY, rtLocalY, 0.01f, TEST_LOCATION);
int UtcDaliRenderTaskRequiresSync(void)
{
TestApplication application;
- RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
RenderTask newTask = taskList.CreateTask();
- newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, false );
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, false);
- DALI_TEST_EQUALS( newTask.GetProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( newTask.GetCurrentProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(newTask.GetProperty<bool>(RenderTask::Property::REQUIRES_SYNC), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(newTask.GetCurrentProperty<bool>(RenderTask::Property::REQUIRES_SYNC), false, TEST_LOCATION);
- newTask.SetProperty( RenderTask::Property::REQUIRES_SYNC, true );
+ newTask.SetProperty(RenderTask::Property::REQUIRES_SYNC, true);
- DALI_TEST_EQUALS( newTask.GetProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( newTask.GetCurrentProperty< bool >( RenderTask::Property::REQUIRES_SYNC ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(newTask.GetProperty<bool>(RenderTask::Property::REQUIRES_SYNC), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(newTask.GetCurrentProperty<bool>(RenderTask::Property::REQUIRES_SYNC), true, TEST_LOCATION);
END_TEST;
}
tet_infoline("UtcDaliRenderTaskSetClearEnabled");
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
TestGlAbstraction& gl = application.GetGlAbstraction();
- Actor renderableActor = CreateRenderableActorSuccess( application, "aFile.jpg" );
- application.GetScene().Add( renderableActor );
+ Actor renderableActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(renderableActor);
Actor rootActor = Actor::New();
- application.GetScene().Add( rootActor );
+ application.GetScene().Add(rootActor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(TestApplication::DEFAULT_SURFACE_WIDTH, TestApplication::DEFAULT_SURFACE_HEIGHT));
+ application.GetScene().Add(offscreenCameraActor);
- Actor sourceActor = CreateRenderableActorSuccess( application, "aFile.jpg" );
- application.GetScene().Add( sourceActor );
+ Actor sourceActor = CreateRenderableActorSuccess(application, "aFile.jpg");
+ application.GetScene().Add(sourceActor);
- RenderTask newTask = CreateRenderTask( application, offscreenCameraActor, rootActor, sourceActor, RenderTask::REFRESH_ALWAYS, false );
+ RenderTask newTask = CreateRenderTask(application, offscreenCameraActor, rootActor, sourceActor, RenderTask::REFRESH_ALWAYS, false);
- DALI_TEST_EQUALS( gl.GetClearCountCalled(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(gl.GetClearCountCalled(), 0, TEST_LOCATION);
application.SendNotification();
application.Render();
// glClear should be called twice - default task and the new task.
- DALI_TEST_EQUALS( gl.GetClearCountCalled(), 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(gl.GetClearCountCalled(), 2, TEST_LOCATION);
- newTask.SetClearEnabled( false );
+ newTask.SetClearEnabled(false);
application.SendNotification();
application.Render();
// The count should increase by 1 - default task only.
- DALI_TEST_EQUALS( gl.GetClearCountCalled(), 3, TEST_LOCATION );
+ DALI_TEST_EQUALS(gl.GetClearCountCalled(), 3, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
+ Vector4 testColor(1.0f, 2.0f, 3.0f, 4.0f);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( task );
- DALI_TEST_EQUALS( 2, task.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( task.GetClearColor() != testColor );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task);
+ DALI_TEST_EQUALS(2, task.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(task.GetClearColor() != testColor);
- task.SetClearColor( testColor );
+ task.SetClearColor(testColor);
// Wait a frame.
Wait(application);
- DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor, TEST_LOCATION);
- RenderTask move = std::move( task );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetClearColor(), testColor, TEST_LOCATION );
- DALI_TEST_CHECK( !task );
+ RenderTask move = std::move(task);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetClearColor(), testColor, TEST_LOCATION);
+ DALI_TEST_CHECK(!task);
END_TEST;
}
{
TestApplication application;
- Vector4 testColor( 1.0f, 2.0f, 3.0f, 4.0f );
+ Vector4 testColor(1.0f, 2.0f, 3.0f, 4.0f);
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask task = taskList.GetTask( 0u );
- DALI_TEST_CHECK( task );
- DALI_TEST_EQUALS( 2, task.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( task.GetClearColor() != testColor );
+ RenderTask task = taskList.GetTask(0u);
+ DALI_TEST_CHECK(task);
+ DALI_TEST_EQUALS(2, task.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(task.GetClearColor() != testColor);
- task.SetClearColor( testColor );
+ task.SetClearColor(testColor);
// Wait a frame.
Wait(application);
- DALI_TEST_EQUALS( task.GetClearColor(), testColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(task.GetClearColor(), testColor, TEST_LOCATION);
RenderTask move;
- move = std::move( task );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetClearColor(), testColor, TEST_LOCATION );
- DALI_TEST_CHECK( !task );
+ move = std::move(task);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetClearColor(), testColor, TEST_LOCATION);
+ DALI_TEST_CHECK(!task);
END_TEST;
}
int UtcDaliRenderTaskSetCullModeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetViewportNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetExclusiveNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetClearColorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskFinishedSignalNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetCameraActorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetFrameBufferNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetRefreshRateNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetSourceActorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetClearEnabledNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetInputEnabledNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetViewportSizeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetViewportPositionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetScreenToFrameBufferFunctionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskSetScreenToFrameBufferMappingActorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetCullModeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetViewportNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskIsExclusiveNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetClearColorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetCameraActorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetFrameBufferNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetRefreshRateNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetSourceActorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetClearEnabledNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetInputEnabledNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskViewportToLocalNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
Dali::Actor arg1(Actor::New());
- float arg2(0.0f);
- float arg3(0.0f);
- float arg4(0.0f);
- float arg5(0.0f);
- instance.ViewportToLocal(arg1,arg2,arg3,arg4,arg5);
+ float arg2(0.0f);
+ float arg3(0.0f);
+ float arg4(0.0f);
+ float arg5(0.0f);
+ instance.ViewportToLocal(arg1, arg2, arg3, arg4, arg5);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliRenderTaskWorldToViewportNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
Dali::Vector3 arg1;
- float arg2(0.0f);
- float arg3(0.0f);
- instance.WorldToViewport(arg1,arg2,arg3);
+ float arg2(0.0f);
+ float arg3(0.0f);
+ instance.WorldToViewport(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliRenderTaskGetCurrentViewportSizeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetCurrentViewportPositionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetScreenToFrameBufferFunctionNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
int UtcDaliRenderTaskGetScreenToFrameBufferMappingActorNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTask instance;
try
{
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
RenderTaskList taskList;
- DALI_TEST_CHECK( ! taskList );
+ DALI_TEST_CHECK(!taskList);
END_TEST;
}
RenderTaskList taskList1;
- RenderTaskList taskList2( taskList1 );
+ RenderTaskList taskList2(taskList1);
- DALI_TEST_CHECK( ! taskList2 );
+ DALI_TEST_CHECK(!taskList2);
END_TEST;
}
taskList1 = taskList2;
- DALI_TEST_CHECK( ! taskList1 );
+ DALI_TEST_CHECK(!taskList1);
END_TEST;
}
TestApplication application;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- DALI_TEST_CHECK( taskList );
- DALI_TEST_EQUALS( 2, taskList.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(taskList);
+ DALI_TEST_EQUALS(2, taskList.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
- RenderTaskList move = std::move( taskList );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( 1u == move.GetTaskCount() );
- DALI_TEST_CHECK( !taskList );
+ RenderTaskList move = std::move(taskList);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(1u == move.GetTaskCount());
+ DALI_TEST_CHECK(!taskList);
END_TEST;
}
TestApplication application;
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- DALI_TEST_CHECK( taskList );
- DALI_TEST_EQUALS( 2, taskList.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(taskList);
+ DALI_TEST_EQUALS(2, taskList.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
RenderTaskList move;
- move = std::move( taskList );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( 1u == move.GetTaskCount() );
- DALI_TEST_CHECK( !taskList );
+ move = std::move(taskList);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(2, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(1u == move.GetTaskCount());
+ DALI_TEST_CHECK(!taskList);
END_TEST;
}
BaseHandle base = application.GetScene().GetRenderTaskList();
- RenderTaskList taskList = RenderTaskList::DownCast( base );
+ RenderTaskList taskList = RenderTaskList::DownCast(base);
- DALI_TEST_CHECK( taskList );
+ DALI_TEST_CHECK(taskList);
// Try calling a method
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
END_TEST;
}
tet_infoline("Testing RenderTaskList::CreateTask()");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
taskList.CreateTask();
- DALI_TEST_CHECK( 2u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(2u == taskList.GetTaskCount());
END_TEST;
}
tet_infoline("Testing RenderTaskList::RemoveTask()");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( 2u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(2u == taskList.GetTaskCount());
- taskList.RemoveTask( newTask );
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ taskList.RemoveTask(newTask);
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
END_TEST;
}
tet_infoline("Testing RenderTaskList::RemoveTask() which has an exclusive actor set");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( 2u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(2u == taskList.GetTaskCount());
auto actor = CreateRenderableActor();
- newTask.SetSourceActor( actor );
- newTask.SetExclusive( true );
- DALI_TEST_EQUALS( actor, newTask.GetSourceActor(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, newTask.IsExclusive(), TEST_LOCATION );
- taskList.RemoveTask( newTask );
+ newTask.SetSourceActor(actor);
+ newTask.SetExclusive(true);
+ DALI_TEST_EQUALS(actor, newTask.GetSourceActor(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, newTask.IsExclusive(), TEST_LOCATION);
+ taskList.RemoveTask(newTask);
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
END_TEST;
}
tet_infoline("Testing RenderTaskList::GetTaskCount()");
RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
- taskList.RemoveTask( taskList.GetTask(0u) );
- DALI_TEST_CHECK( 0u == taskList.GetTaskCount() );
+ taskList.RemoveTask(taskList.GetTask(0u));
+ DALI_TEST_CHECK(0u == taskList.GetTaskCount());
END_TEST;
}
tet_infoline("Testing RenderTaskList::GetTask()");
- RenderTaskList taskList = application.GetScene().GetRenderTaskList();
- RenderTask defaultTask = taskList.GetTask( 0u );
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
- DALI_TEST_CHECK( defaultTask );
- DALI_TEST_CHECK( defaultTask == taskList.GetTask( 0u ) );
+ RenderTaskList taskList = application.GetScene().GetRenderTaskList();
+ RenderTask defaultTask = taskList.GetTask(0u);
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
+ DALI_TEST_CHECK(defaultTask);
+ DALI_TEST_CHECK(defaultTask == taskList.GetTask(0u));
RenderTask newTask = taskList.CreateTask();
- DALI_TEST_CHECK( 2u == taskList.GetTaskCount() );
+ DALI_TEST_CHECK(2u == taskList.GetTaskCount());
- RenderTask temp = taskList.GetTask( 0u );
- RenderTask temp2 = taskList.GetTask( 1u );
+ RenderTask temp = taskList.GetTask(0u);
+ RenderTask temp2 = taskList.GetTask(1u);
- DALI_TEST_CHECK( newTask );
- DALI_TEST_CHECK( defaultTask != newTask );
- DALI_TEST_CHECK( taskList.GetTask( 0u ) == defaultTask );
- DALI_TEST_CHECK( taskList.GetTask( 1u ) == newTask );
- DALI_TEST_CHECK( taskList.GetTask( 1u ) != defaultTask );
+ DALI_TEST_CHECK(newTask);
+ DALI_TEST_CHECK(defaultTask != newTask);
+ DALI_TEST_CHECK(taskList.GetTask(0u) == defaultTask);
+ DALI_TEST_CHECK(taskList.GetTask(1u) == newTask);
+ DALI_TEST_CHECK(taskList.GetTask(1u) != defaultTask);
- taskList.RemoveTask( taskList.GetTask(0u) );
- DALI_TEST_CHECK( 1u == taskList.GetTaskCount() );
- DALI_TEST_CHECK( taskList.GetTask( 0u ) != defaultTask );
- DALI_TEST_CHECK( taskList.GetTask( 0u ) == newTask );
+ taskList.RemoveTask(taskList.GetTask(0u));
+ DALI_TEST_CHECK(1u == taskList.GetTaskCount());
+ DALI_TEST_CHECK(taskList.GetTask(0u) != defaultTask);
+ DALI_TEST_CHECK(taskList.GetTask(0u) == newTask);
END_TEST;
}
int UtcDaliRenderTaskListCreateTaskNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTaskList instance;
try
{
int UtcDaliRenderTaskListRemoveTaskNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTaskList instance;
try
{
int UtcDaliRenderTaskListGetTaskCountNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTaskList instance;
try
{
int UtcDaliRenderTaskListGetTaskNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::RenderTaskList instance;
try
{
// EXTERNAL INCLUDES
#include <dali/devel-api/actors/actor-devel.h>
-#include <dali/devel-api/rendering/renderer-devel.h>
#include <dali/devel-api/common/stage.h>
-
-#include <dali/public-api/dali-core.h>
+#include <dali/devel-api/rendering/renderer-devel.h>
#include <dali/integration-api/render-task-list-integ.h>
+#include <dali/public-api/dali-core.h>
+
#include <cstdio>
#include <string>
// INTERNAL INCLUDES
#include <dali-test-suite-utils.h>
-#include <test-trace-call-stack.h>
#include <mesh-builder.h>
+#include <test-trace-call-stack.h>
using namespace Dali;
namespace // unnamed namespace
{
+const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_RGB(BlendFactor::SRC_ALPHA);
+const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_RGB(BlendFactor::ONE_MINUS_SRC_ALPHA);
+const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_ALPHA(BlendFactor::ONE);
+const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_ALPHA(BlendFactor::ONE_MINUS_SRC_ALPHA);
-const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_RGB( BlendFactor::SRC_ALPHA );
-const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_RGB( BlendFactor::ONE_MINUS_SRC_ALPHA );
-const BlendFactor::Type DEFAULT_BLEND_FACTOR_SRC_ALPHA( BlendFactor::ONE );
-const BlendFactor::Type DEFAULT_BLEND_FACTOR_DEST_ALPHA( BlendFactor::ONE_MINUS_SRC_ALPHA );
-
-const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB( BlendEquation::ADD );
-const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA( BlendEquation::ADD );
+const BlendEquation::Type DEFAULT_BLEND_EQUATION_RGB(BlendEquation::ADD);
+const BlendEquation::Type DEFAULT_BLEND_EQUATION_ALPHA(BlendEquation::ADD);
/**
* @brief Get GL stencil test enumeration value as a string.
return stream.str();
}
-void ResetDebugAndFlush( TestApplication& application, TraceCallStack& glEnableDisableStack, TraceCallStack& glStencilFunctionStack )
+void ResetDebugAndFlush(TestApplication& application, TraceCallStack& glEnableDisableStack, TraceCallStack& glStencilFunctionStack)
{
glEnableDisableStack.Reset();
glStencilFunctionStack.Reset();
application.Render();
}
-void TestConstraintNoBlue( Vector4& current, const PropertyInputContainer& inputs )
+void TestConstraintNoBlue(Vector4& current, const PropertyInputContainer& inputs)
{
current.b = 0.0f;
}
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- DALI_TEST_EQUALS( (bool)renderer, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)renderer, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliRendererNew02(void)
{
TestApplication application;
- Renderer renderer;
- DALI_TEST_EQUALS( (bool)renderer, false, TEST_LOCATION );
+ Renderer renderer;
+ DALI_TEST_EQUALS((bool)renderer, false, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Renderer rendererCopy( renderer );
- DALI_TEST_EQUALS( (bool)rendererCopy, true, TEST_LOCATION );
+ Renderer rendererCopy(renderer);
+ DALI_TEST_EQUALS((bool)rendererCopy, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
Renderer renderer2;
- DALI_TEST_EQUALS( (bool)renderer2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)renderer2, false, TEST_LOCATION);
renderer2 = renderer;
- DALI_TEST_EQUALS( (bool)renderer2, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)renderer2, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
- DALI_TEST_CHECK( renderer );
- DALI_TEST_EQUALS( 1, renderer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::TRANSPARENT, TEST_LOCATION );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
+ DALI_TEST_CHECK(renderer);
+ DALI_TEST_EQUALS(1, renderer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::MAGENTA );
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::MAGENTA, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
- Renderer move = std::move( renderer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::MAGENTA, TEST_LOCATION );
- DALI_TEST_CHECK( !renderer );
+ Renderer move = std::move(renderer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_CHECK(!renderer);
END_TEST;
}
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
- DALI_TEST_CHECK( renderer );
- DALI_TEST_EQUALS( 1, renderer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::TRANSPARENT, TEST_LOCATION );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
+ DALI_TEST_CHECK(renderer);
+ DALI_TEST_EQUALS(1, renderer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::MAGENTA );
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::MAGENTA, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
Renderer move;
- move = std::move( renderer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::MAGENTA, TEST_LOCATION );
- DALI_TEST_CHECK( !renderer );
+ move = std::move(renderer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_CHECK(!renderer);
END_TEST;
}
TestApplication application;
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
BaseHandle handle(renderer);
- Renderer renderer2 = Renderer::DownCast(handle);
- DALI_TEST_EQUALS( (bool)renderer2, true, TEST_LOCATION );
+ Renderer renderer2 = Renderer::DownCast(handle);
+ DALI_TEST_EQUALS((bool)renderer2, true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Handle handle = Handle::New(); // Create a custom object
+ Handle handle = Handle::New(); // Create a custom object
Renderer renderer = Renderer::DownCast(handle);
- DALI_TEST_EQUALS( (bool)renderer, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)renderer, false, TEST_LOCATION);
END_TEST;
}
// using a template to auto deduce the parameter types
-template< typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-void TEST_RENDERER_PROPERTY( P1 renderer, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION )
+template<typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
+void TEST_RENDERER_PROPERTY(P1 renderer, P2 stringName, P3 type, P4 isWriteable, P5 isAnimateable, P6 isConstraintInput, P7 enumName, P8 LOCATION)
{
- DALI_TEST_EQUALS( renderer.GetPropertyName( enumName ), stringName, LOCATION );
- DALI_TEST_EQUALS( renderer.GetPropertyIndex( stringName ), static_cast<Property::Index>(enumName), LOCATION );
- DALI_TEST_EQUALS( renderer.GetPropertyType( enumName ), type, LOCATION );
- DALI_TEST_EQUALS( renderer.IsPropertyWritable( enumName ), isWriteable, LOCATION );
- DALI_TEST_EQUALS( renderer.IsPropertyAnimatable( enumName ), isAnimateable, LOCATION );
- DALI_TEST_EQUALS( renderer.IsPropertyAConstraintInput( enumName ), isConstraintInput, LOCATION );
+ DALI_TEST_EQUALS(renderer.GetPropertyName(enumName), stringName, LOCATION);
+ DALI_TEST_EQUALS(renderer.GetPropertyIndex(stringName), static_cast<Property::Index>(enumName), LOCATION);
+ DALI_TEST_EQUALS(renderer.GetPropertyType(enumName), type, LOCATION);
+ DALI_TEST_EQUALS(renderer.IsPropertyWritable(enumName), isWriteable, LOCATION);
+ DALI_TEST_EQUALS(renderer.IsPropertyAnimatable(enumName), isAnimateable, LOCATION);
+ DALI_TEST_EQUALS(renderer.IsPropertyAConstraintInput(enumName), isConstraintInput, LOCATION);
}
int UtcDaliRendererDefaultProperties(void)
{
TestApplication application;
-/* from renderer-impl.cpp
+ /* from renderer-impl.cpp
DALI_PROPERTY( "depthIndex", INTEGER, true, false, false, Dali::Renderer::Property::DEPTH_INDEX )
DALI_PROPERTY( "faceCullingMode", INTEGER, true, false, false, Dali::Renderer::Property::FACE_CULLING_MODE )
DALI_PROPERTY( "blendMode", INTEGER, true, false, false, Dali::Renderer::Property::BLEND_MODE )
*/
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- DALI_TEST_EQUALS( renderer.GetPropertyCount(), 26, TEST_LOCATION );
-
- TEST_RENDERER_PROPERTY( renderer, "depthIndex", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_INDEX, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "faceCullingMode", Property::INTEGER, true, false, false, Renderer::Property::FACE_CULLING_MODE, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendMode", Property::INTEGER, true, false, false, Renderer::Property::BLEND_MODE, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendEquationRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_RGB, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendEquationAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_ALPHA, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendFactorSrcRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_RGB, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendFactorDestRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_RGB, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendFactorSrcAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendFactorDestAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendColor", Property::VECTOR4, true, false, false, Renderer::Property::BLEND_COLOR, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "blendPreMultipliedAlpha", Property::BOOLEAN, true, false, false, Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "indexRangeFirst", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_FIRST, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "indexRangeCount", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_COUNT, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "depthWriteMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_WRITE_MODE, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "depthFunction", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_FUNCTION, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "depthTestMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_TEST_MODE, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "renderMode", Property::INTEGER, true, false, false, Renderer::Property::RENDER_MODE, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilFunction", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilFunctionMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_MASK, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilFunctionReference",Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_REFERENCE, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_MASK, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilOperationOnFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_FAIL, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilOperationOnZFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "stencilOperationOnZPass", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "opacity", Property::FLOAT, true, true, true, DevelRenderer::Property::OPACITY, TEST_LOCATION );
- TEST_RENDERER_PROPERTY( renderer, "renderingBehavior", Property::INTEGER, true, false, false, DevelRenderer::Property::RENDERING_BEHAVIOR, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetPropertyCount(), 26, TEST_LOCATION);
+
+ TEST_RENDERER_PROPERTY(renderer, "depthIndex", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_INDEX, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "faceCullingMode", Property::INTEGER, true, false, false, Renderer::Property::FACE_CULLING_MODE, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendMode", Property::INTEGER, true, false, false, Renderer::Property::BLEND_MODE, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendEquationRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_RGB, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendEquationAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_EQUATION_ALPHA, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendFactorSrcRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_RGB, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendFactorDestRgb", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_RGB, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendFactorSrcAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendFactorDestAlpha", Property::INTEGER, true, false, false, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendColor", Property::VECTOR4, true, false, false, Renderer::Property::BLEND_COLOR, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "blendPreMultipliedAlpha", Property::BOOLEAN, true, false, false, Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "indexRangeFirst", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_FIRST, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "indexRangeCount", Property::INTEGER, true, false, false, Renderer::Property::INDEX_RANGE_COUNT, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "depthWriteMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_WRITE_MODE, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "depthFunction", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_FUNCTION, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "depthTestMode", Property::INTEGER, true, false, false, Renderer::Property::DEPTH_TEST_MODE, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "renderMode", Property::INTEGER, true, false, false, Renderer::Property::RENDER_MODE, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilFunction", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilFunctionMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_MASK, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilFunctionReference", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_FUNCTION_REFERENCE, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilMask", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_MASK, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilOperationOnFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_FAIL, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilOperationOnZFail", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "stencilOperationOnZPass", Property::INTEGER, true, false, false, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "opacity", Property::FLOAT, true, true, true, DevelRenderer::Property::OPACITY, TEST_LOCATION);
+ TEST_RENDERER_PROPERTY(renderer, "renderingBehavior", Property::INTEGER, true, false, false, DevelRenderer::Property::RENDERING_BEHAVIOR, TEST_LOCATION);
END_TEST;
}
int UtcDaliRendererSetGetGeometry(void)
{
TestApplication application;
- tet_infoline( "Test SetGeometry, GetGeometry" );
+ tet_infoline("Test SetGeometry, GetGeometry");
Geometry geometry1 = CreateQuadGeometry();
Geometry geometry2 = CreateQuadGeometry();
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry1, shader);
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetGeometry(), geometry1, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetGeometry(), geometry1, TEST_LOCATION);
// Set geometry2 to the renderer
- renderer.SetGeometry( geometry2 );
+ renderer.SetGeometry(geometry2);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetGeometry(), geometry2, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetGeometry(), geometry2, TEST_LOCATION);
END_TEST;
}
int UtcDaliRendererSetGetShader(void)
{
TestApplication application;
- tet_infoline( "Test SetShader, GetShader" );
+ tet_infoline("Test SetShader, GetShader");
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableCullFaceCallTrace(true);
Shader shader1 = CreateShader();
- shader1.RegisterProperty( "uFadeColor", Color::RED );
+ shader1.RegisterProperty("uFadeColor", Color::RED);
Shader shader2 = CreateShader();
- shader2.RegisterProperty( "uFadeColor", Color::GREEN );
+ shader2.RegisterProperty("uFadeColor", Color::GREEN);
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, shader1);
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that the first shaders's fade color property is accessed
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::RED, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::RED, TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetShader(), shader1, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetShader(), shader1, TEST_LOCATION);
// set the second shader to the renderer
- renderer.SetShader( shader2 );
+ renderer.SetShader(shader2);
application.SendNotification();
application.Render(0);
// Expect that the second shader's fade color property is accessed
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
- DALI_TEST_EQUALS( renderer.GetShader(), shader2, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetShader(), shader2, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test SetDepthIndex, GetDepthIndex");
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Geometry geometry = CreateQuadGeometry();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION);
- renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 1 );
+ renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 1);
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 0, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION);
- renderer.SetProperty( Renderer::Property::DEPTH_INDEX, 10 );
+ renderer.SetProperty(Renderer::Property::DEPTH_INDEX, 10);
- DALI_TEST_EQUALS( renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<int>(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 1, TEST_LOCATION);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<int>(Renderer::Property::DEPTH_INDEX), 10, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test SetFaceCullingMode(cullingMode)");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
// By default, none of the faces should be culled
- unsigned int cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< FaceCullingMode::Type >( cullFace ) == FaceCullingMode::NONE );
+ unsigned int cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
+ DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::NONE);
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& cullFaceStack = gl.GetCullFaceTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& cullFaceStack = gl.GetCullFaceTrace();
gl.EnableCullFaceCallTrace(true);
{
cullFaceStack.Reset();
- renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT_AND_BACK );
+ renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT_AND_BACK);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( cullFaceStack.CountMethod( "CullFace" ), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 1, TEST_LOCATION);
std::ostringstream cullModeString;
cullModeString << GL_FRONT_AND_BACK;
- DALI_TEST_CHECK( cullFaceStack.FindMethodAndParams( "CullFace", cullModeString.str() ) );
- cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< FaceCullingMode::Type >( cullFace ) == FaceCullingMode::FRONT_AND_BACK );
+ DALI_TEST_CHECK(cullFaceStack.FindMethodAndParams("CullFace", cullModeString.str()));
+ cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
+ DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::FRONT_AND_BACK);
}
{
cullFaceStack.Reset();
- renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK );
+ renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::BACK);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( cullFaceStack.CountMethod( "CullFace" ), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 1, TEST_LOCATION);
std::ostringstream cullModeString;
cullModeString << GL_BACK;
- DALI_TEST_CHECK( cullFaceStack.FindMethodAndParams( "CullFace", cullModeString.str() ) );
- cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< FaceCullingMode::Type >( cullFace ) == FaceCullingMode::BACK );
+ DALI_TEST_CHECK(cullFaceStack.FindMethodAndParams("CullFace", cullModeString.str()));
+ cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
+ DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::BACK);
}
{
cullFaceStack.Reset();
- renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT );
+ renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::FRONT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( cullFaceStack.CountMethod( "CullFace" ), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 1, TEST_LOCATION);
std::ostringstream cullModeString;
cullModeString << GL_FRONT;
- DALI_TEST_CHECK( cullFaceStack.FindMethodAndParams( "CullFace", cullModeString.str() ) );
- cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< FaceCullingMode::Type >( cullFace ) == FaceCullingMode::FRONT );
+ DALI_TEST_CHECK(cullFaceStack.FindMethodAndParams("CullFace", cullModeString.str()));
+ cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
+ DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::FRONT);
}
{
cullFaceStack.Reset();
- renderer.SetProperty( Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE );
+ renderer.SetProperty(Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( cullFaceStack.CountMethod( "CullFace" ), 0, TEST_LOCATION );
- cullFace = renderer.GetProperty<int>( Renderer::Property::FACE_CULLING_MODE );
- DALI_TEST_CHECK( static_cast< FaceCullingMode::Type >( cullFace ) == FaceCullingMode::NONE );
+ DALI_TEST_EQUALS(cullFaceStack.CountMethod("CullFace"), 0, TEST_LOCATION);
+ cullFace = renderer.GetProperty<int>(Renderer::Property::FACE_CULLING_MODE);
+ DALI_TEST_CHECK(static_cast<FaceCullingMode::Type>(cullFace) == FaceCullingMode::NONE);
}
END_TEST;
tet_infoline("Test BLEND_FACTOR properties ");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
// set a transparent actor color so that blending is enabled
- actor.SetProperty( Actor::Property::OPACITY, 0.5f );
+ actor.SetProperty(Actor::Property::OPACITY, 0.5f);
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE_MINUS_SRC_COLOR );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::SRC_ALPHA_SATURATE );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_COLOR );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::SRC_ALPHA_SATURATE );
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::ONE_MINUS_SRC_COLOR);
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::SRC_ALPHA_SATURATE);
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_COLOR);
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::SRC_ALPHA_SATURATE);
// Test that Set was successful:
- int srcFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
- int destFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
- int srcFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
- int destFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
+ int srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
+ int destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
+ int srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
+ int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_COLOR, srcFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::SRC_ALPHA_SATURATE, destFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_COLOR, srcFactorAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::SRC_ALPHA_SATURATE, destFactorAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_COLOR, srcFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::SRC_ALPHA_SATURATE, destFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_COLOR, srcFactorAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::SRC_ALPHA_SATURATE, destFactorAlpha, TEST_LOCATION);
application.SendNotification();
application.Render();
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_SRC_ALPHA_SATURATE, glAbstraction.GetLastBlendFuncDstRgb(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_SRC_ALPHA_SATURATE, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION );
+ DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_SRC_ALPHA_SATURATE, glAbstraction.GetLastBlendFuncDstRgb(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_SRC_COLOR, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_SRC_ALPHA_SATURATE, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION);
END_TEST;
}
tet_infoline("Test BLEND_FACTOR properties ");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::OPACITY, 0.5f ); // enable blending
+ actor.SetProperty(Actor::Property::OPACITY, 0.5f); // enable blending
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::CONSTANT_COLOR );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_CONSTANT_COLOR );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::CONSTANT_ALPHA );
- renderer.SetProperty( Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_CONSTANT_ALPHA );
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::CONSTANT_COLOR);
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_CONSTANT_COLOR);
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::CONSTANT_ALPHA);
+ renderer.SetProperty(Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_CONSTANT_ALPHA);
// Test that Set was successful:
{
- int srcFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
- int destFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
- int srcFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
- int destFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
-
- DALI_TEST_EQUALS( (int)BlendFactor::CONSTANT_COLOR, srcFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_CONSTANT_COLOR, destFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::CONSTANT_ALPHA, srcFactorAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_CONSTANT_ALPHA, destFactorAlpha, TEST_LOCATION );
+ int srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
+ int destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
+ int srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
+ int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
+
+ DALI_TEST_EQUALS((int)BlendFactor::CONSTANT_COLOR, srcFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_CONSTANT_COLOR, destFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::CONSTANT_ALPHA, srcFactorAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_CONSTANT_ALPHA, destFactorAlpha, TEST_LOCATION);
}
application.SendNotification();
application.Render();
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- DALI_TEST_EQUALS( (GLenum)GL_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncDstRgb(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_ONE_MINUS_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION );
+ DALI_TEST_EQUALS((GLenum)GL_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncSrcRgb(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_CONSTANT_COLOR, glAbstraction.GetLastBlendFuncDstRgb(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncSrcAlpha(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_ONE_MINUS_CONSTANT_ALPHA, glAbstraction.GetLastBlendFuncDstAlpha(), TEST_LOCATION);
END_TEST;
}
tet_infoline("Test GetBlendEquation() defaults ");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
// Test the defaults as documented in blending.h
- int equationRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_EQUATION_RGB );
- int equationAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_EQUATION_ALPHA );
+ int equationRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_RGB);
+ int equationAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_ALPHA);
- DALI_TEST_EQUALS( (int)BlendEquation::ADD, equationRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendEquation::ADD, equationAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS((int)BlendEquation::ADD, equationRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendEquation::ADD, equationAlpha, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test SetBlendEquation() ");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::OPACITY, 0.1f );
+ actor.SetProperty(Actor::Property::OPACITY, 0.1f);
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
// Test the single blending equation setting
{
- renderer.SetProperty( Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::REVERSE_SUBTRACT );
- int equationRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_EQUATION_RGB );
- DALI_TEST_EQUALS( (int)BlendEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION );
+ renderer.SetProperty(Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::REVERSE_SUBTRACT);
+ int equationRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_RGB);
+ DALI_TEST_EQUALS((int)BlendEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION);
}
- renderer.SetProperty( Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::REVERSE_SUBTRACT );
- renderer.SetProperty( Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::REVERSE_SUBTRACT );
+ renderer.SetProperty(Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::REVERSE_SUBTRACT);
+ renderer.SetProperty(Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::REVERSE_SUBTRACT);
// Test that Set was successful
{
- int equationRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_EQUATION_RGB );
- int equationAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_EQUATION_ALPHA );
- DALI_TEST_EQUALS( (int)BlendEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendEquation::REVERSE_SUBTRACT, equationAlpha, TEST_LOCATION );
+ int equationRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_RGB);
+ int equationAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_EQUATION_ALPHA);
+ DALI_TEST_EQUALS((int)BlendEquation::REVERSE_SUBTRACT, equationRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendEquation::REVERSE_SUBTRACT, equationAlpha, TEST_LOCATION);
}
// Render & check GL commands
application.Render();
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- DALI_TEST_EQUALS( (GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationRgb(), TEST_LOCATION );
- DALI_TEST_EQUALS( (GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationAlpha(), TEST_LOCATION );
+ DALI_TEST_EQUALS((GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationRgb(), TEST_LOCATION);
+ DALI_TEST_EQUALS((GLenum)GL_FUNC_REVERSE_SUBTRACT, glAbstraction.GetLastBlendEquationAlpha(), TEST_LOCATION);
END_TEST;
}
tet_infoline("Test setting the blend mode to on with an opaque color renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::OPACITY, 0.98f );
+ actor.SetProperty(Actor::Property::OPACITY, 0.98f);
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to on with an transparent color renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::OPACITY, 0.0f );
+ actor.SetProperty(Actor::Property::OPACITY, 0.0f);
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
- glAbstraction.EnableDrawCallTrace( true );
+ glAbstraction.EnableDrawCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( !glEnableStack.FindMethod( "Enable" ) );
+ DALI_TEST_CHECK(!glEnableStack.FindMethod("Enable"));
- DALI_TEST_CHECK( !glAbstraction.GetDrawTrace().FindMethod( "DrawElements" ) );
+ DALI_TEST_CHECK(!glAbstraction.GetDrawTrace().FindMethod("DrawElements"));
END_TEST;
}
tet_infoline("Test setting the blend mode to off with a transparent color renders with blending disabled (and not enabled)");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::OPACITY, 0.15f );
+ actor.SetProperty(Actor::Property::OPACITY, 0.15f);
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::OFF);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::OFF);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with a transparent color renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::OPACITY, 0.75f );
+ actor.SetProperty(Actor::Property::OPACITY, 0.75f);
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with an opaque color renders with blending disabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with a transparent actor color renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with an opaque opaque actor color renders with blending disabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Color::MAGENTA );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Color::MAGENTA);
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with an opaque color and an image with an alpha channel renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 40, 40);
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 40, 40);
- Shader shader = CreateShader();
- TextureSet textureSet = CreateTextureSet( image );
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Shader shader = CreateShader();
+ TextureSet textureSet = CreateTextureSet(image);
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_TRANSPARENT renders with blending enabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT);
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.SendNotification();
application.Render();
- TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
+ TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
std::ostringstream blendStr;
blendStr << GL_BLEND;
- DALI_TEST_CHECK( glEnableStack.FindMethodAndParams( "Enable", blendStr.str().c_str() ) );
+ DALI_TEST_CHECK(glEnableStack.FindMethodAndParams("Enable", blendStr.str().c_str()));
END_TEST;
}
tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_OPAQUE renders with blending disabled");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGB888, 50, 50);
- TextureSet textureSet = CreateTextureSet( image );
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGB888, 50, 50);
+ TextureSet textureSet = CreateTextureSet(image);
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::AUTO);
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::AUTO);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
application.Render();
TraceCallStack& glEnableStack = glAbstraction.GetEnableDisableTrace();
- DALI_TEST_CHECK( ! glEnableStack.FindMethodAndParams( "Enable", "GL_BLEND" ) );
+ DALI_TEST_CHECK(!glEnableStack.FindMethodAndParams("Enable", "GL_BLEND"));
END_TEST;
}
tet_infoline("Test GetBlendMode()");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
// default value
- unsigned int mode = renderer.GetProperty<int>( Renderer::Property::BLEND_MODE );
- DALI_TEST_EQUALS( static_cast< BlendMode::Type >( mode ), BlendMode::AUTO, TEST_LOCATION );
+ unsigned int mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
+ DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::AUTO, TEST_LOCATION);
// ON
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
- mode = renderer.GetProperty<int>( Renderer::Property::BLEND_MODE );
- DALI_TEST_EQUALS( static_cast< BlendMode::Type >( mode ), BlendMode::ON, TEST_LOCATION );
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
+ mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
+ DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::ON, TEST_LOCATION);
// OFF
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::OFF );
- mode = renderer.GetProperty<int>( Renderer::Property::BLEND_MODE );
- DALI_TEST_EQUALS( static_cast< BlendMode::Type >( mode ), BlendMode::OFF, TEST_LOCATION );
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::OFF);
+ mode = renderer.GetProperty<int>(Renderer::Property::BLEND_MODE);
+ DALI_TEST_EQUALS(static_cast<BlendMode::Type>(mode), BlendMode::OFF, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test SetBlendColor(color)");
- Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
+ Geometry geometry = CreateQuadGeometry();
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
TextureSet textureSet = TextureSet::New();
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 50, 50);
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 50, 50);
textureSet.SetTexture(0u, image);
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::TRANSPARENT );
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::TRANSPARENT);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( renderer.GetProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION );
- DALI_TEST_EQUALS( glAbstraction.GetLastBlendColor(), Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
+ DALI_TEST_EQUALS(glAbstraction.GetLastBlendColor(), Color::TRANSPARENT, TEST_LOCATION);
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::MAGENTA );
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
- DALI_TEST_EQUALS( renderer.GetProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION );
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION );
- DALI_TEST_EQUALS( glAbstraction.GetLastBlendColor(), Color::MAGENTA, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_EQUALS(glAbstraction.GetLastBlendColor(), Color::MAGENTA, TEST_LOCATION);
- Vector4 color( 0.1f, 0.2f, 0.3f, 0.4f );
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, color );
+ Vector4 color(0.1f, 0.2f, 0.3f, 0.4f);
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, color);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( glAbstraction.GetLastBlendColor(), color, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetLastBlendColor(), color, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test GetBlendColor()");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::TRANSPARENT, TEST_LOCATION);
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, Color::MAGENTA );
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, Color::MAGENTA);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), Color::MAGENTA, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), Color::MAGENTA, TEST_LOCATION);
- Vector4 color( 0.1f, 0.2f, 0.3f, 0.4f );
- renderer.SetProperty( Renderer::Property::BLEND_COLOR, color );
+ Vector4 color(0.1f, 0.2f, 0.3f, 0.4f);
+ renderer.SetProperty(Renderer::Property::BLEND_COLOR, color);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>( Renderer::Property::BLEND_COLOR ), color, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(Renderer::Property::BLEND_COLOR), color, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test BLEND_PRE_MULTIPLIED_ALPHA property");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 0.5f));
application.GetScene().Add(actor);
- Property::Value value = renderer.GetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
- bool preMultipliedAlpha;
- DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) );
- DALI_TEST_CHECK( !preMultipliedAlpha );
+ Property::Value value = renderer.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
+ bool preMultipliedAlpha;
+ DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
+ DALI_TEST_CHECK(!preMultipliedAlpha);
- int srcFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
- int destFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
- int srcFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
- int destFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
+ int srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
+ int destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
+ int srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
+ int destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
- DALI_TEST_EQUALS( (int)DEFAULT_BLEND_FACTOR_SRC_RGB, srcFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)DEFAULT_BLEND_FACTOR_DEST_RGB, destFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)DEFAULT_BLEND_FACTOR_SRC_ALPHA, srcFactorAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)DEFAULT_BLEND_FACTOR_DEST_ALPHA, destFactorAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_SRC_RGB, srcFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_DEST_RGB, destFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_SRC_ALPHA, srcFactorAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)DEFAULT_BLEND_FACTOR_DEST_ALPHA, destFactorAlpha, TEST_LOCATION);
application.SendNotification();
application.Render();
- Vector4 actualValue(Vector4::ZERO);
+ Vector4 actualValue(Vector4::ZERO);
TestGlAbstraction& gl = application.GetGlAbstraction();
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
// Enable pre-multiplied alpha
- renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true );
+ renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, true);
application.SendNotification();
application.Render();
- value = renderer.GetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
- DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) );
- DALI_TEST_CHECK( preMultipliedAlpha );
+ value = renderer.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
+ DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
+ DALI_TEST_CHECK(preMultipliedAlpha);
- value = renderer.GetCurrentProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
- DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) );
- DALI_TEST_CHECK( preMultipliedAlpha );
+ value = renderer.GetCurrentProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
+ DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
+ DALI_TEST_CHECK(preMultipliedAlpha);
- srcFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
- destFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
- srcFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
- destFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
+ srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
+ destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
+ srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
+ destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
- DALI_TEST_EQUALS( (int)BlendFactor::ONE, srcFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS((int)BlendFactor::ONE, srcFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Vector4(0.5f, 0.0f, 0.5f, 0.5f), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Vector4(0.5f, 0.0f, 0.5f, 0.5f), TEST_LOCATION);
// Disable pre-multiplied alpha again
- renderer.SetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, false );
+ renderer.SetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA, false);
application.SendNotification();
application.Render();
- value = renderer.GetProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
- DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) );
- DALI_TEST_CHECK( !preMultipliedAlpha );
+ value = renderer.GetProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
+ DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
+ DALI_TEST_CHECK(!preMultipliedAlpha);
- value = renderer.GetCurrentProperty( Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA );
- DALI_TEST_CHECK( value.Get( preMultipliedAlpha ) );
- DALI_TEST_CHECK( !preMultipliedAlpha );
+ value = renderer.GetCurrentProperty(Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA);
+ DALI_TEST_CHECK(value.Get(preMultipliedAlpha));
+ DALI_TEST_CHECK(!preMultipliedAlpha);
- srcFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_RGB );
- destFactorRgb = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_RGB );
- srcFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_SRC_ALPHA );
- destFactorAlpha = renderer.GetProperty<int>( Renderer::Property::BLEND_FACTOR_DEST_ALPHA );
+ srcFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_RGB);
+ destFactorRgb = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_RGB);
+ srcFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_SRC_ALPHA);
+ destFactorAlpha = renderer.GetProperty<int>(Renderer::Property::BLEND_FACTOR_DEST_ALPHA);
- DALI_TEST_EQUALS( (int)BlendFactor::SRC_ALPHA, srcFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION );
- DALI_TEST_EQUALS( (int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION );
+ DALI_TEST_EQUALS((int)BlendFactor::SRC_ALPHA, srcFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorRgb, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE, srcFactorAlpha, TEST_LOCATION);
+ DALI_TEST_EQUALS((int)BlendFactor::ONE_MINUS_SRC_ALPHA, destFactorAlpha, TEST_LOCATION);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Vector4( 1.0f, 0.0f, 1.0f, 0.5f ), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Vector4(1.0f, 0.0f, 1.0f, 0.5f), TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a non-uniform renderer property can be constrained");
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION);
// Apply constraint
- Constraint constraint = Constraint::New<Vector4>( renderer, colorIndex, TestConstraintNoBlue );
+ Constraint constraint = Constraint::New<Vector4>(renderer, colorIndex, TestConstraintNoBlue);
constraint.Apply();
application.SendNotification();
application.Render(0);
// Expect no blue component in either buffer - yellow
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::YELLOW, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::YELLOW, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION);
renderer.RemoveConstraints();
- renderer.SetProperty(colorIndex, Color::WHITE );
+ renderer.SetProperty(colorIndex, Color::WHITE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a uniform map renderer property can be constrained");
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
TestGlAbstraction& gl = application.GetGlAbstraction();
application.Render(0);
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, initialColor, TEST_LOCATION);
// Apply constraint
- Constraint constraint = Constraint::New<Vector4>( renderer, colorIndex, TestConstraintNoBlue );
+ Constraint constraint = Constraint::New<Vector4>(renderer, colorIndex, TestConstraintNoBlue);
constraint.Apply();
application.SendNotification();
application.Render(0);
- // Expect no blue component in either buffer - yellow
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
+ // Expect no blue component in either buffer - yellow
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::YELLOW, TEST_LOCATION);
application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::YELLOW, TEST_LOCATION);
renderer.RemoveConstraints();
- renderer.SetProperty(colorIndex, Color::WHITE );
+ renderer.SetProperty(colorIndex, Color::WHITE);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::WHITE, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a non-uniform renderer property can be animated");
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION);
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, initialColor);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( renderer, colorIndex ), keyFrames );
+ animation.AnimateBetween(Property(renderer, colorIndex), keyFrames);
animation.Play();
application.SendNotification();
application.Render(500);
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::WHITE * 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION);
application.Render(500);
- DALI_TEST_EQUALS( renderer.GetCurrentProperty< Vector4 >( colorIndex ), Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_EQUALS(renderer.GetCurrentProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a uniform map renderer property can be animated");
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = renderer.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = renderer.RegisterProperty("uFadeColor", initialColor);
TestGlAbstraction& gl = application.GetGlAbstraction();
application.Render(0);
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, initialColor, TEST_LOCATION);
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, initialColor);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( renderer, colorIndex ), keyFrames );
+ animation.AnimateBetween(Property(renderer, colorIndex), keyFrames);
animation.Play();
application.SendNotification();
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE * 0.5f, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::WHITE * 0.5f, TEST_LOCATION);
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::TRANSPARENT, TEST_LOCATION);
END_TEST;
}
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- renderer.RegisterProperty( "uFadeColor", Color::RED );
- actor.RegisterProperty( "uFadeColor", Color::GREEN );
- Property::Index shaderFadeColorIndex = shader.RegisterProperty( "uFadeColor", Color::MAGENTA );
+ renderer.RegisterProperty("uFadeColor", Color::RED);
+ actor.RegisterProperty("uFadeColor", Color::GREEN);
+ Property::Index shaderFadeColorIndex = shader.RegisterProperty("uFadeColor", Color::MAGENTA);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that the actor's fade color property is accessed
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
// Animate shader's fade color property. Should be no change to uniform
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, Color::WHITE);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( shader, shaderFadeColorIndex ), keyFrames );
+ animation.AnimateBetween(Property(shader, shaderFadeColorIndex), keyFrames);
animation.Play();
application.SendNotification();
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
END_TEST;
}
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
// Don't add property / uniform map to renderer
- actor.RegisterProperty( "uFadeColor", Color::GREEN );
- Property::Index shaderFadeColorIndex = shader.RegisterProperty( "uFadeColor", Color::BLUE );
+ actor.RegisterProperty("uFadeColor", Color::GREEN);
+ Property::Index shaderFadeColorIndex = shader.RegisterProperty("uFadeColor", Color::BLUE);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that the actor's fade color property is accessed
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
// Animate texture set's fade color property. Should be no change to uniform
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, Color::WHITE);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( shader, shaderFadeColorIndex ), keyFrames );
+ animation.AnimateBetween(Property(shader, shaderFadeColorIndex), keyFrames);
animation.Play();
application.SendNotification();
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::GREEN, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRendererUniformMapPrecendence03(void)
{
TestApplication application;
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
// Don't add property / uniform map to renderer or actor
- shader.RegisterProperty( "uFadeColor", Color::BLACK );
+ shader.RegisterProperty("uFadeColor", Color::BLACK);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that the shader's fade color property is accessed
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::BLACK, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::BLACK, TEST_LOCATION);
END_TEST;
}
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- renderer.RegisterProperty( "uUniform1", Color::RED );
- actor.RegisterProperty( "uUniform2", Color::GREEN );
- shader.RegisterProperty( "uUniform3", Color::MAGENTA );
+ renderer.RegisterProperty("uUniform1", Color::RED);
+ actor.RegisterProperty("uUniform2", Color::GREEN);
+ shader.RegisterProperty("uUniform3", Color::MAGENTA);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that each of the object's uniforms are set
Vector4 uniform1Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform1", uniform1Value ) );
- DALI_TEST_EQUALS( uniform1Value, Color::RED, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uUniform1", uniform1Value));
+ DALI_TEST_EQUALS(uniform1Value, Color::RED, TEST_LOCATION);
Vector4 uniform2Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform2", uniform2Value ) );
- DALI_TEST_EQUALS( uniform2Value, Color::GREEN, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uUniform2", uniform2Value));
+ DALI_TEST_EQUALS(uniform2Value, Color::GREEN, TEST_LOCATION);
Vector4 uniform3Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uUniform3", uniform3Value ) );
- DALI_TEST_EQUALS( uniform3Value, Color::MAGENTA, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uUniform3", uniform3Value));
+ DALI_TEST_EQUALS(uniform3Value, Color::MAGENTA, TEST_LOCATION);
END_TEST;
}
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = Shader::New("VertexSource", "FragmentSource");
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
Property::Value value1(Color::RED);
- renderer.RegisterProperty( "uFadeColor", value1 );
+ renderer.RegisterProperty("uFadeColor", value1);
Property::Value value2(1.0f);
- actor.RegisterProperty( "uFadeProgress", value2 );
+ actor.RegisterProperty("uFadeProgress", value2);
Property::Value value3(Matrix3::IDENTITY);
- shader.RegisterProperty( "uANormalMatrix", value3 );
+ shader.RegisterProperty("uANormalMatrix", value3);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Expect that each of the object's uniforms are set
Vector4 uniform1Value(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", uniform1Value ) );
- DALI_TEST_EQUALS( uniform1Value, value1.Get<Vector4>(), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", uniform1Value));
+ DALI_TEST_EQUALS(uniform1Value, value1.Get<Vector4>(), TEST_LOCATION);
float uniform2Value(0.0f);
- DALI_TEST_CHECK( gl.GetUniformValue<float>( "uFadeProgress", uniform2Value ) );
- DALI_TEST_EQUALS( uniform2Value, value2.Get<float>(), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<float>("uFadeProgress", uniform2Value));
+ DALI_TEST_EQUALS(uniform2Value, value2.Get<float>(), TEST_LOCATION);
Matrix3 uniform3Value;
- DALI_TEST_CHECK( gl.GetUniformValue<Matrix3>( "uANormalMatrix", uniform3Value ) );
- DALI_TEST_EQUALS( uniform3Value, value3.Get<Matrix3>(), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Matrix3>("uANormalMatrix", uniform3Value));
+ DALI_TEST_EQUALS(uniform3Value, value3.Get<Matrix3>(), TEST_LOCATION);
END_TEST;
}
-
-Renderer CreateRenderer( Actor actor, Geometry geometry, Shader shader, int depthIndex )
+Renderer CreateRenderer(Actor actor, Geometry geometry, Shader shader, int depthIndex)
{
- Texture image0 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGB888, 64, 64);
- TextureSet textureSet0 = CreateTextureSet( image0 );
- Renderer renderer0 = Renderer::New( geometry, shader );
- renderer0.SetTextures( textureSet0 );
- renderer0.SetProperty( Renderer::Property::DEPTH_INDEX, depthIndex );
+ Texture image0 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGB888, 64, 64);
+ TextureSet textureSet0 = CreateTextureSet(image0);
+ Renderer renderer0 = Renderer::New(geometry, shader);
+ renderer0.SetTextures(textureSet0);
+ renderer0.SetProperty(Renderer::Property::DEPTH_INDEX, depthIndex);
actor.AddRenderer(renderer0);
return renderer0;
}
-
-Actor CreateActor( Actor parent, int siblingOrder, const char* location )
+Actor CreateActor(Actor parent, int siblingOrder, const char* location)
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN,AnchorPoint::CENTER);
- actor.SetProperty( Actor::Property::POSITION, Vector2(0.0f,0.0f));
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
parent.Add(actor);
- actor.SetProperty( Dali::DevelActor::Property::SIBLING_ORDER, siblingOrder );
- DALI_TEST_EQUALS( actor.GetProperty<int>( Dali::DevelActor::Property::SIBLING_ORDER), siblingOrder, TEST_INNER_LOCATION(location) );
+ actor.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, siblingOrder);
+ DALI_TEST_EQUALS(actor.GetProperty<int>(Dali::DevelActor::Property::SIBLING_ORDER), siblingOrder, TEST_INNER_LOCATION(location));
return actor;
}
TestApplication application;
tet_infoline("Test the rendering order in a 2D layer is correct");
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
Actor root = application.GetScene().GetRootLayer();
- Actor actor0 = CreateActor( root, 0, TEST_LOCATION );
- Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 0 );
+ Actor actor0 = CreateActor(root, 0, TEST_LOCATION);
+ Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 0);
- Actor actor1 = CreateActor( root, 0, TEST_LOCATION );
- Renderer renderer1 = CreateRenderer( actor1, geometry, shader, 0 );
+ Actor actor1 = CreateActor(root, 0, TEST_LOCATION);
+ Renderer renderer1 = CreateRenderer(actor1, geometry, shader, 0);
- Actor actor2 = CreateActor( root, 0, TEST_LOCATION );
- Renderer renderer2 = CreateRenderer( actor2, geometry, shader, 0 );
+ Actor actor2 = CreateActor(root, 0, TEST_LOCATION);
+ Renderer renderer2 = CreateRenderer(actor2, geometry, shader, 0);
- Actor actor3 = CreateActor( root, 0, TEST_LOCATION );
- Renderer renderer3 = CreateRenderer( actor3, geometry, shader, 0 );
+ Actor actor3 = CreateActor(root, 0, TEST_LOCATION);
+ Renderer renderer3 = CreateRenderer(actor3, geometry, shader, 0);
application.SendNotification();
application.Render(0);
application.Render(0);
int textureBindIndex[4];
- for( unsigned int i(0); i<4; ++i )
+ for(unsigned int i(0); i < 4; ++i)
{
std::stringstream params;
- params << GL_TEXTURE_2D<<", "<<i+1;
- textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+ params << GL_TEXTURE_2D << ", " << i + 1;
+ textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
}
//Check that actor1 has been rendered after actor2
- DALI_TEST_GREATER( textureBindIndex[1], textureBindIndex[2], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[1], textureBindIndex[2], TEST_LOCATION);
//Check that actor0 has been rendered after actor1
- DALI_TEST_GREATER( textureBindIndex[0], textureBindIndex[1], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[0], textureBindIndex[1], TEST_LOCATION);
//Check that actor3 has been rendered after actor0
- DALI_TEST_GREATER( textureBindIndex[3], textureBindIndex[0], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[3], textureBindIndex[0], TEST_LOCATION);
END_TEST;
}
* Expected rendering order: renderer1 - renderer2 - renderer0 - renderer5 - renderer4 - renderer3
*/
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
Actor root = application.GetScene().GetRootLayer();
- Actor actor0 = CreateActor( root, 0, TEST_LOCATION );
- Actor actor1 = CreateActor( actor0, 0, TEST_LOCATION );
- Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 2 );
- Renderer renderer1 = CreateRenderer( actor0, geometry, shader, 0 );
- Renderer renderer2 = CreateRenderer( actor0, geometry, shader, 1 );
- Renderer renderer3 = CreateRenderer( actor1, geometry, shader, 1 );
- Renderer renderer4 = CreateRenderer( actor1, geometry, shader, 0 );
- Renderer renderer5 = CreateRenderer( actor1, geometry, shader, -1 );
+ Actor actor0 = CreateActor(root, 0, TEST_LOCATION);
+ Actor actor1 = CreateActor(actor0, 0, TEST_LOCATION);
+ Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 2);
+ Renderer renderer1 = CreateRenderer(actor0, geometry, shader, 0);
+ Renderer renderer2 = CreateRenderer(actor0, geometry, shader, 1);
+ Renderer renderer3 = CreateRenderer(actor1, geometry, shader, 1);
+ Renderer renderer4 = CreateRenderer(actor1, geometry, shader, 0);
+ Renderer renderer5 = CreateRenderer(actor1, geometry, shader, -1);
application.SendNotification();
application.Render(0);
application.Render(0);
int textureBindIndex[6];
- for( unsigned int i(0); i<6; ++i )
+ for(unsigned int i(0); i < 6; ++i)
{
std::stringstream params;
- params << GL_TEXTURE_2D<<", "<<i+1;
- textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+ params << GL_TEXTURE_2D << ", " << i + 1;
+ textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
}
//Check that renderer3 has been rendered after renderer4
- DALI_TEST_GREATER( textureBindIndex[3], textureBindIndex[4], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[3], textureBindIndex[4], TEST_LOCATION);
//Check that renderer0 has been rendered after renderer2
- DALI_TEST_GREATER( textureBindIndex[4], textureBindIndex[5], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[4], textureBindIndex[5], TEST_LOCATION);
//Check that renderer5 has been rendered after renderer2
- DALI_TEST_GREATER( textureBindIndex[5], textureBindIndex[0], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[5], textureBindIndex[0], TEST_LOCATION);
//Check that renderer0 has been rendered after renderer2
- DALI_TEST_GREATER( textureBindIndex[0], textureBindIndex[2], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[0], textureBindIndex[2], TEST_LOCATION);
//Check that renderer2 has been rendered after renderer1
- DALI_TEST_GREATER( textureBindIndex[2], textureBindIndex[1], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[2], textureBindIndex[1], TEST_LOCATION);
END_TEST;
}
-
int UtcDaliRendererRenderOrder2DLayerSiblingOrder(void)
{
TestApplication application;
* Expected rendering order: renderer2 - renderer3 - renderer4 - renderer1 - renderer0 - renderer5
*/
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Actor root = application.GetScene().GetRootLayer();
- Actor actor0 = CreateActor( root, 1, TEST_LOCATION );
- Actor actor1 = CreateActor( root, 0, TEST_LOCATION );
- Actor actor2 = CreateActor( actor0, 0, TEST_LOCATION );
+ Actor root = application.GetScene().GetRootLayer();
+ Actor actor0 = CreateActor(root, 1, TEST_LOCATION);
+ Actor actor1 = CreateActor(root, 0, TEST_LOCATION);
+ Actor actor2 = CreateActor(actor0, 0, TEST_LOCATION);
- Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 2 );
- Renderer renderer1 = CreateRenderer( actor0, geometry, shader, 0 );
- Renderer renderer2 = CreateRenderer( actor1, geometry, shader, 0 );
- Renderer renderer3 = CreateRenderer( actor1, geometry, shader, 1 );
- Renderer renderer4 = CreateRenderer( actor1, geometry, shader, 2 );
- Renderer renderer5 = CreateRenderer( actor2, geometry, shader, -1 );
+ Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 2);
+ Renderer renderer1 = CreateRenderer(actor0, geometry, shader, 0);
+ Renderer renderer2 = CreateRenderer(actor1, geometry, shader, 0);
+ Renderer renderer3 = CreateRenderer(actor1, geometry, shader, 1);
+ Renderer renderer4 = CreateRenderer(actor1, geometry, shader, 2);
+ Renderer renderer5 = CreateRenderer(actor2, geometry, shader, -1);
application.SendNotification();
application.Render();
application.Render(0);
int textureBindIndex[6];
- for( unsigned int i(0); i<6; ++i )
+ for(unsigned int i(0); i < 6; ++i)
{
std::stringstream params;
- params << GL_TEXTURE_2D<<", "<<i+1;
- textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+ params << GL_TEXTURE_2D << ", " << i + 1;
+ textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
}
- DALI_TEST_EQUALS( textureBindIndex[2], 0, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[3], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[4], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[1], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[0], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[5], 5, TEST_LOCATION );
+ DALI_TEST_EQUALS(textureBindIndex[2], 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[3], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[4], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[1], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[0], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[5], 5, TEST_LOCATION);
// Change sibling order of actor1
// New Expected rendering order: renderer1 - renderer0 - renderer 5 - renderer2 - renderer3 - renderer4
- actor1.SetProperty( Dali::DevelActor::Property::SIBLING_ORDER, 2 );
+ actor1.SetProperty(Dali::DevelActor::Property::SIBLING_ORDER, 2);
gl.GetTextureTrace().Reset();
application.SendNotification();
application.Render(0);
- for( unsigned int i(0); i<6; ++i )
+ for(unsigned int i(0); i < 6; ++i)
{
std::stringstream params;
- params << GL_TEXTURE_2D<<", "<<i+1;
- textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+ params << GL_TEXTURE_2D << ", " << i + 1;
+ textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
}
- DALI_TEST_EQUALS( textureBindIndex[1], 0, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[0], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[5], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[2], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[3], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( textureBindIndex[4], 5, TEST_LOCATION );
+ DALI_TEST_EQUALS(textureBindIndex[1], 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[0], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[5], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[2], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[3], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureBindIndex[4], 5, TEST_LOCATION);
END_TEST;
}
TestApplication application;
tet_infoline("Test the rendering order in a 2D layer is correct for overlays");
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Actor root = application.GetScene().GetRootLayer();
+ Actor root = application.GetScene().GetRootLayer();
/*
* Create the following hierarchy:
* Expected rendering order : actor2 - actor4 - actor1 - actor0 - actor3
*/
- Actor actor0 = CreateActor( root, 0, TEST_LOCATION );
- actor0.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
- Renderer renderer0 = CreateRenderer( actor0, geometry, shader, 0 );
+ Actor actor0 = CreateActor(root, 0, TEST_LOCATION);
+ actor0.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
+ Renderer renderer0 = CreateRenderer(actor0, geometry, shader, 0);
- Actor actor1 = CreateActor( root, 0, TEST_LOCATION );
- actor1.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
- Renderer renderer1 = CreateRenderer( actor1, geometry, shader, 0 );
+ Actor actor1 = CreateActor(root, 0, TEST_LOCATION);
+ actor1.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
+ Renderer renderer1 = CreateRenderer(actor1, geometry, shader, 0);
- Actor actor2 = CreateActor( root, 0, TEST_LOCATION );
- Renderer renderer2 = CreateRenderer( actor2, geometry, shader, 0 );
+ Actor actor2 = CreateActor(root, 0, TEST_LOCATION);
+ Renderer renderer2 = CreateRenderer(actor2, geometry, shader, 0);
- Actor actor3 = CreateActor( root, 0, TEST_LOCATION );
- actor3.SetProperty( Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D );
- Renderer renderer3 = CreateRenderer( actor3, geometry, shader, 0 );
+ Actor actor3 = CreateActor(root, 0, TEST_LOCATION);
+ actor3.SetProperty(Actor::Property::DRAW_MODE, DrawMode::OVERLAY_2D);
+ Renderer renderer3 = CreateRenderer(actor3, geometry, shader, 0);
- Actor actor4 = CreateActor( root, 0, TEST_LOCATION );
- Renderer renderer4 = CreateRenderer( actor4, geometry, shader, 0 );
+ Actor actor4 = CreateActor(root, 0, TEST_LOCATION);
+ Renderer renderer4 = CreateRenderer(actor4, geometry, shader, 0);
application.SendNotification();
application.Render(0);
application.Render(0);
int textureBindIndex[5];
- for( unsigned int i(0); i<5; ++i )
+ for(unsigned int i(0); i < 5; ++i)
{
std::stringstream params;
- params << GL_TEXTURE_2D<<", "<<i+1;
- textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str() );
+ params << GL_TEXTURE_2D << ", " << i + 1;
+ textureBindIndex[i] = gl.GetTextureTrace().FindIndexFromMethodAndParams("BindTexture", params.str());
}
//Check that actor4 has been rendered after actor2
- DALI_TEST_GREATER( textureBindIndex[4], textureBindIndex[2], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[4], textureBindIndex[2], TEST_LOCATION);
//Check that actor1 has been rendered after actor4
- DALI_TEST_GREATER( textureBindIndex[1], textureBindIndex[4], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[1], textureBindIndex[4], TEST_LOCATION);
//Check that actor0 has been rendered after actor1
- DALI_TEST_GREATER( textureBindIndex[0], textureBindIndex[1], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[0], textureBindIndex[1], TEST_LOCATION);
//Check that actor3 has been rendered after actor0
- DALI_TEST_GREATER( textureBindIndex[3], textureBindIndex[0], TEST_LOCATION );
+ DALI_TEST_GREATER(textureBindIndex[3], textureBindIndex[0], TEST_LOCATION);
END_TEST;
}
int UtcDaliRendererSetIndexRange(void)
{
std::string
- vertexShader(
- "attribute vec2 aPosition;\n"
- "void main()\n"
- "{\n"
- " gl_Position = aPosition;\n"
- "}"
- ),
- fragmentShader(
- "void main()\n"
- "{\n"
- " gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0)\n"
- "}\n"
- );
+ vertexShader(
+ "attribute vec2 aPosition;\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = aPosition;\n"
+ "}"),
+ fragmentShader(
+ "void main()\n"
+ "{\n"
+ " gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0)\n"
+ "}\n");
TestApplication application;
tet_infoline("Test setting the range of indices to draw");
TestGlAbstraction& gl = application.GetGlAbstraction();
- gl.EnableDrawCallTrace( true );
+ gl.EnableDrawCallTrace(true);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
// create geometry
Geometry geometry = Geometry::New();
- geometry.SetType( Geometry::LINE_LOOP );
+ geometry.SetType(Geometry::LINE_LOOP);
// --------------------------------------------------------------------------
// index buffer
- unsigned short indices[] = { 0, 2, 4, 6, 8, // offset = 0, count = 5
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // offset = 5, count = 10
- 1, 3, 5, 7, 9, 1 }; // offset = 15, count = 6 // line strip
+ unsigned short indices[] = {0, 2, 4, 6, 8, // offset = 0, count = 5
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9, // offset = 5, count = 10
+ 1,
+ 3,
+ 5,
+ 7,
+ 9,
+ 1}; // offset = 15, count = 6 // line strip
// --------------------------------------------------------------------------
// vertex buffer
Vector2 position;
};
Vertex shapes[] =
- {
- // pentagon // star
- { Vector2( 0.0f, 1.00f) }, { Vector2( 0.0f, -1.00f) },
- { Vector2( -0.95f, 0.31f) }, { Vector2( 0.59f, 0.81f) },
- { Vector2( -0.59f, -0.81f) }, { Vector2( -0.95f, -0.31f) },
- { Vector2( 0.59f, -0.81f) }, { Vector2( 0.95f, -0.31f) },
- { Vector2( 0.95f, 0.31f) }, { Vector2( -0.59f, 0.81f) },
- };
+ {
+ // pentagon // star
+ {Vector2(0.0f, 1.00f)},
+ {Vector2(0.0f, -1.00f)},
+ {Vector2(-0.95f, 0.31f)},
+ {Vector2(0.59f, 0.81f)},
+ {Vector2(-0.59f, -0.81f)},
+ {Vector2(-0.95f, -0.31f)},
+ {Vector2(0.59f, -0.81f)},
+ {Vector2(0.95f, -0.31f)},
+ {Vector2(0.95f, 0.31f)},
+ {Vector2(-0.59f, 0.81f)},
+ };
Property::Map vertexFormat;
vertexFormat["aPosition"] = Property::VECTOR2;
- VertexBuffer vertexBuffer = VertexBuffer::New( vertexFormat );
- vertexBuffer.SetData( shapes, sizeof(shapes)/sizeof(shapes[0]));
+ VertexBuffer vertexBuffer = VertexBuffer::New(vertexFormat);
+ vertexBuffer.SetData(shapes, sizeof(shapes) / sizeof(shapes[0]));
// --------------------------------------------------------------------------
- geometry.SetIndexBuffer( indices, sizeof(indices)/sizeof(indices[0]) );
- geometry.AddVertexBuffer( vertexBuffer );
+ geometry.SetIndexBuffer(indices, sizeof(indices) / sizeof(indices[0]));
+ geometry.AddVertexBuffer(vertexBuffer);
// create shader
- Shader shader = Shader::New( vertexShader,fragmentShader );
- Renderer renderer = Renderer::New( geometry, shader );
- actor.AddRenderer( renderer );
+ Shader shader = Shader::New(vertexShader, fragmentShader);
+ Renderer renderer = Renderer::New(geometry, shader);
+ actor.AddRenderer(renderer);
Integration::Scene scene = application.GetScene();
- scene.Add( actor );
+ scene.Add(actor);
- char buffer[ 128 ];
+ char buffer[128];
// LINE_LOOP, first 0, count 5
{
- renderer.SetIndexRange( 0, 5 );
+ renderer.SetIndexRange(0, 5);
application.SendNotification();
application.Render();
- Property::Value value = renderer.GetProperty( Renderer::Property::INDEX_RANGE_FIRST );
- int convertedValue;
- DALI_TEST_CHECK( value.Get( convertedValue ) );
- DALI_TEST_CHECK( convertedValue == 0 );
+ Property::Value value = renderer.GetProperty(Renderer::Property::INDEX_RANGE_FIRST);
+ int convertedValue;
+ DALI_TEST_CHECK(value.Get(convertedValue));
+ DALI_TEST_CHECK(convertedValue == 0);
- value = renderer.GetCurrentProperty( Renderer::Property::INDEX_RANGE_FIRST );
- DALI_TEST_CHECK( value.Get( convertedValue ) );
- DALI_TEST_CHECK( convertedValue == 0 );
+ value = renderer.GetCurrentProperty(Renderer::Property::INDEX_RANGE_FIRST);
+ DALI_TEST_CHECK(value.Get(convertedValue));
+ DALI_TEST_CHECK(convertedValue == 0);
- value = renderer.GetProperty( Renderer::Property::INDEX_RANGE_COUNT );
- DALI_TEST_CHECK( value.Get( convertedValue ) );
- DALI_TEST_CHECK( convertedValue == 5 );
+ value = renderer.GetProperty(Renderer::Property::INDEX_RANGE_COUNT);
+ DALI_TEST_CHECK(value.Get(convertedValue));
+ DALI_TEST_CHECK(convertedValue == 5);
- value = renderer.GetCurrentProperty( Renderer::Property::INDEX_RANGE_COUNT );
- DALI_TEST_CHECK( value.Get( convertedValue ) );
- DALI_TEST_CHECK( convertedValue == 5 );
+ value = renderer.GetCurrentProperty(Renderer::Property::INDEX_RANGE_COUNT);
+ DALI_TEST_CHECK(value.Get(convertedValue));
+ DALI_TEST_CHECK(convertedValue == 5);
- sprintf( buffer, "%u, 5, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT );
- bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer );
- DALI_TEST_CHECK( result );
+ sprintf(buffer, "%u, 5, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT);
+ bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
+ DALI_TEST_CHECK(result);
}
// LINE_LOOP, first 5, count 10
{
- renderer.SetIndexRange( 5, 10 );
- sprintf( buffer, "%u, 10, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT );
+ renderer.SetIndexRange(5, 10);
+ sprintf(buffer, "%u, 10, %u, indices", GL_LINE_LOOP, GL_UNSIGNED_SHORT);
application.SendNotification();
application.Render();
- bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer );
- DALI_TEST_CHECK( result );
+ bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
+ DALI_TEST_CHECK(result);
}
// LINE_STRIP, first 15, count 6
{
- renderer.SetIndexRange( 15, 6 );
- geometry.SetType( Geometry::LINE_STRIP );
- sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT );
+ renderer.SetIndexRange(15, 6);
+ geometry.SetType(Geometry::LINE_STRIP);
+ sprintf(buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT);
application.SendNotification();
application.Render();
- bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer );
- DALI_TEST_CHECK( result );
+ bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
+ DALI_TEST_CHECK(result);
}
// Index out of bounds
{
- renderer.SetIndexRange( 15, 30 );
- geometry.SetType( Geometry::LINE_STRIP );
- sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT );
+ renderer.SetIndexRange(15, 30);
+ geometry.SetType(Geometry::LINE_STRIP);
+ sprintf(buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT);
application.SendNotification();
application.Render();
- bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer );
- DALI_TEST_CHECK( result );
+ bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
+ DALI_TEST_CHECK(result);
}
// drawing whole buffer starting from 15 ( last valid primitive )
{
- renderer.SetIndexRange( 15, 0 );
- geometry.SetType( Geometry::LINE_STRIP );
- sprintf( buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT );
+ renderer.SetIndexRange(15, 0);
+ geometry.SetType(Geometry::LINE_STRIP);
+ sprintf(buffer, "%u, 6, %u, indices", GL_LINE_STRIP, GL_UNSIGNED_SHORT);
application.SendNotification();
application.Render();
- bool result = gl.GetDrawTrace().FindMethodAndParams( "DrawElements" , buffer );
- DALI_TEST_CHECK( result );
+ bool result = gl.GetDrawTrace().FindMethodAndParams("DrawElements", buffer);
+ DALI_TEST_CHECK(result);
}
END_TEST;
}
-
int UtcDaliRendererSetDepthFunction(void)
{
TestApplication application;
tet_infoline("Test setting the depth function");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
Integration::Scene scene = application.GetScene();
- scene.GetRootLayer().SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
+ scene.GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
scene.Add(actor);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
//GL_NEVER
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::NEVER);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::NEVER);
glEnableDisableStack.Reset();
glDepthFunctionStack.Reset();
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", depthTestStr.str().c_str() ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", depthTestStr.str().c_str()));
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_NEVER;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_ALWAYS
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::ALWAYS);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::ALWAYS);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_ALWAYS;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_LESS
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_LESS;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_GREATER
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::GREATER);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::GREATER);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_GREATER;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_EQUAL
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::EQUAL);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::EQUAL);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_EQUAL;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_NOTEQUAL
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::NOT_EQUAL);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::NOT_EQUAL);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_NOTEQUAL;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_LEQUAL
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS_EQUAL);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS_EQUAL);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_LEQUAL;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
//GL_GEQUAL
{
- renderer.SetProperty( Renderer::Property::DEPTH_FUNCTION, DepthFunction::GREATER_EQUAL);
+ renderer.SetProperty(Renderer::Property::DEPTH_FUNCTION, DepthFunction::GREATER_EQUAL);
glDepthFunctionStack.Reset();
application.SendNotification();
std::ostringstream depthFunctionStr;
depthFunctionStr << GL_GEQUAL;
- DALI_TEST_CHECK( glDepthFunctionStack.FindMethodAndParams( "DepthFunc", depthFunctionStr.str().c_str() ) );
+ DALI_TEST_CHECK(glDepthFunctionStack.FindMethodAndParams("DepthFunc", depthFunctionStr.str().c_str()));
}
END_TEST;
* - Set a different value via string.
* - Check it was set.
*/
-template< typename T >
-void CheckEnumerationProperty( TestApplication& application, Renderer& renderer, Property::Index propertyIndex, T initialValue, T firstCheckEnumeration, T secondCheckEnumeration, std::string secondCheckString )
+template<typename T>
+void CheckEnumerationProperty(TestApplication& application, Renderer& renderer, Property::Index propertyIndex, T initialValue, T firstCheckEnumeration, T secondCheckEnumeration, std::string secondCheckString)
{
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( initialValue ) );
- DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) == static_cast<int>( initialValue ) );
- renderer.SetProperty( propertyIndex, firstCheckEnumeration );
- DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( firstCheckEnumeration ) );
- DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) != static_cast<int>( firstCheckEnumeration ) );
+ DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(initialValue));
+ DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) == static_cast<int>(initialValue));
+ renderer.SetProperty(propertyIndex, firstCheckEnumeration);
+ DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(firstCheckEnumeration));
+ DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) != static_cast<int>(firstCheckEnumeration));
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( firstCheckEnumeration ) );
- DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) == static_cast<int>( firstCheckEnumeration ) );
+ DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(firstCheckEnumeration));
+ DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) == static_cast<int>(firstCheckEnumeration));
- renderer.SetProperty( propertyIndex, secondCheckString );
- DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( secondCheckEnumeration ) );
- DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) != static_cast<int>( secondCheckEnumeration ) );
+ renderer.SetProperty(propertyIndex, secondCheckString);
+ DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(secondCheckEnumeration));
+ DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) != static_cast<int>(secondCheckEnumeration));
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( renderer.GetProperty<int>( propertyIndex ) == static_cast<int>( secondCheckEnumeration ) );
- DALI_TEST_CHECK( renderer.GetCurrentProperty< int >( propertyIndex ) == static_cast<int>( secondCheckEnumeration ) );
+ DALI_TEST_CHECK(renderer.GetProperty<int>(propertyIndex) == static_cast<int>(secondCheckEnumeration));
+ DALI_TEST_CHECK(renderer.GetCurrentProperty<int>(propertyIndex) == static_cast<int>(secondCheckEnumeration));
}
int UtcDaliRendererEnumProperties(void)
{
TestApplication application;
- tet_infoline( "Test Renderer enumeration properties can be set with both integer and string values" );
+ tet_infoline("Test Renderer enumeration properties can be set with both integer and string values");
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
/*
* @see CheckEnumerationProperty for details of the checks performed.
*/
- CheckEnumerationProperty< FaceCullingMode::Type >( application, renderer, Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE, FaceCullingMode::FRONT, FaceCullingMode::BACK, "BACK" );
- CheckEnumerationProperty< BlendMode::Type >( application, renderer, Renderer::Property::BLEND_MODE, BlendMode::AUTO, BlendMode::OFF, BlendMode::ON, "ON" );
- CheckEnumerationProperty< BlendEquation::Type >( application, renderer, Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" );
- CheckEnumerationProperty< BlendEquation::Type >( application, renderer, Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT" );
- CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
- CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
- CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::SRC_COLOR, "SRC_COLOR" );
- CheckEnumerationProperty< BlendFactor::Type >( application, renderer, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR" );
- CheckEnumerationProperty< DepthWriteMode::Type >( application, renderer, Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO, DepthWriteMode::OFF, DepthWriteMode::ON, "ON" );
- CheckEnumerationProperty< DepthFunction::Type >( application, renderer, Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS, DepthFunction::ALWAYS, DepthFunction::GREATER, "GREATER" );
- CheckEnumerationProperty< DepthTestMode::Type >( application, renderer, Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO, DepthTestMode::OFF, DepthTestMode::ON, "ON" );
- CheckEnumerationProperty< StencilFunction::Type >( application, renderer, Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS, StencilFunction::LESS, StencilFunction::EQUAL, "EQUAL" );
- CheckEnumerationProperty< RenderMode::Type >( application, renderer, Renderer::Property::RENDER_MODE, RenderMode::AUTO, RenderMode::NONE, RenderMode::STENCIL, "STENCIL" );
- CheckEnumerationProperty< StencilOperation::Type >( application, renderer, Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
- CheckEnumerationProperty< StencilOperation::Type >( application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
- CheckEnumerationProperty< StencilOperation::Type >( application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT" );
+ CheckEnumerationProperty<FaceCullingMode::Type>(application, renderer, Renderer::Property::FACE_CULLING_MODE, FaceCullingMode::NONE, FaceCullingMode::FRONT, FaceCullingMode::BACK, "BACK");
+ CheckEnumerationProperty<BlendMode::Type>(application, renderer, Renderer::Property::BLEND_MODE, BlendMode::AUTO, BlendMode::OFF, BlendMode::ON, "ON");
+ CheckEnumerationProperty<BlendEquation::Type>(application, renderer, Renderer::Property::BLEND_EQUATION_RGB, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT");
+ CheckEnumerationProperty<BlendEquation::Type>(application, renderer, Renderer::Property::BLEND_EQUATION_ALPHA, BlendEquation::ADD, BlendEquation::SUBTRACT, BlendEquation::REVERSE_SUBTRACT, "REVERSE_SUBTRACT");
+ CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_SRC_RGB, BlendFactor::SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR");
+ CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_DEST_RGB, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR");
+ CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_SRC_ALPHA, BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::SRC_COLOR, "SRC_COLOR");
+ CheckEnumerationProperty<BlendFactor::Type>(application, renderer, Renderer::Property::BLEND_FACTOR_DEST_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA, BlendFactor::ONE, BlendFactor::SRC_COLOR, "SRC_COLOR");
+ CheckEnumerationProperty<DepthWriteMode::Type>(application, renderer, Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO, DepthWriteMode::OFF, DepthWriteMode::ON, "ON");
+ CheckEnumerationProperty<DepthFunction::Type>(application, renderer, Renderer::Property::DEPTH_FUNCTION, DepthFunction::LESS, DepthFunction::ALWAYS, DepthFunction::GREATER, "GREATER");
+ CheckEnumerationProperty<DepthTestMode::Type>(application, renderer, Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO, DepthTestMode::OFF, DepthTestMode::ON, "ON");
+ CheckEnumerationProperty<StencilFunction::Type>(application, renderer, Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS, StencilFunction::LESS, StencilFunction::EQUAL, "EQUAL");
+ CheckEnumerationProperty<RenderMode::Type>(application, renderer, Renderer::Property::RENDER_MODE, RenderMode::AUTO, RenderMode::NONE, RenderMode::STENCIL, "STENCIL");
+ CheckEnumerationProperty<StencilOperation::Type>(application, renderer, Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT");
+ CheckEnumerationProperty<StencilOperation::Type>(application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT");
+ CheckEnumerationProperty<StencilOperation::Type>(application, renderer, Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::KEEP, StencilOperation::REPLACE, StencilOperation::INCREMENT, "INCREMENT");
END_TEST;
}
-Renderer RendererTestFixture( TestApplication& application )
+Renderer RendererTestFixture(TestApplication& application)
{
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
Integration::Scene scene = application.GetScene();
- scene.GetRootLayer().SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_3D );
- scene.Add( actor );
+ scene.GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_3D);
+ scene.Add(actor);
return renderer;
}
TestApplication application;
tet_infoline("Test setting the DepthTestMode");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace( true );
+ glAbstraction.EnableEnableDisableCallTrace(true);
TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
glEnableDisableStack.Reset();
application.Render();
// Check depth-test is enabled by default.
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
- DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetDepthTestString()));
+ DALI_TEST_CHECK(!glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
// Turn off depth-testing. We want to check if the depth buffer has been disabled, so we need to turn off depth-write as well for this case.
- renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF );
- renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
+ renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::OFF);
+ renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF);
glEnableDisableStack.Reset();
application.SendNotification();
application.Render();
// Check the depth buffer was disabled.
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
// Turn on automatic mode depth-testing.
// Layer behavior is currently set to LAYER_3D so AUTO should enable depth-testing.
- renderer.SetProperty( Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO );
+ renderer.SetProperty(Renderer::Property::DEPTH_TEST_MODE, DepthTestMode::AUTO);
glEnableDisableStack.Reset();
application.SendNotification();
application.Render();
// Check depth-test is now enabled.
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
- DALI_TEST_CHECK( !glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetDepthTestString()));
+ DALI_TEST_CHECK(!glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
// Change the layer behavior to LAYER_UI.
// Note this will also disable depth testing for the layer by default, we test this first.
- application.GetScene().GetRootLayer().SetProperty( Layer::Property::BEHAVIOR, Layer::LAYER_UI );
+ application.GetScene().GetRootLayer().SetProperty(Layer::Property::BEHAVIOR, Layer::LAYER_UI);
glEnableDisableStack.Reset();
application.SendNotification();
application.Render();
// Check depth-test is disabled.
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Disable", GetDepthTestString() ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Disable", GetDepthTestString()));
// Turn the layer depth-test flag back on, and confirm that depth testing is now on.
- application.GetScene().GetRootLayer().SetProperty(Layer::Property::DEPTH_TEST, true );
+ application.GetScene().GetRootLayer().SetProperty(Layer::Property::DEPTH_TEST, true);
glEnableDisableStack.Reset();
application.SendNotification();
application.Render();
// Check depth-test is *still* disabled.
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetDepthTestString() ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetDepthTestString()));
END_TEST;
}
TestApplication application;
tet_infoline("Test setting the DepthWriteMode");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
application.SendNotification();
application.Render();
// Check the default depth-write status first.
- DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() );
+ DALI_TEST_CHECK(glAbstraction.GetLastDepthMask());
// Turn off depth-writing.
- renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF );
+ renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::OFF);
application.SendNotification();
application.Render();
// Check depth-write is now disabled.
- DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() );
+ DALI_TEST_CHECK(!glAbstraction.GetLastDepthMask());
// Test the AUTO mode for depth-writing.
// As our renderer is opaque, depth-testing should be enabled.
- renderer.SetProperty( Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO );
+ renderer.SetProperty(Renderer::Property::DEPTH_WRITE_MODE, DepthWriteMode::AUTO);
application.SendNotification();
application.Render();
// Check depth-write is now enabled.
- DALI_TEST_CHECK( glAbstraction.GetLastDepthMask() );
+ DALI_TEST_CHECK(glAbstraction.GetLastDepthMask());
// Now make the renderer be treated as translucent by enabling blending.
// The AUTO depth-write mode should turn depth-write off in this scenario.
- renderer.SetProperty( Renderer::Property::BLEND_MODE, BlendMode::ON );
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, BlendMode::ON);
application.SendNotification();
application.Render();
// Check depth-write is now disabled.
- DALI_TEST_CHECK( !glAbstraction.GetLastDepthMask() );
+ DALI_TEST_CHECK(!glAbstraction.GetLastDepthMask());
END_TEST;
}
TestApplication application;
tet_infoline("Test the stencil defaults");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace( true );
- glAbstraction.EnableStencilFunctionCallTrace( true );
- TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
+ glAbstraction.EnableEnableDisableCallTrace(true);
+ glAbstraction.EnableStencilFunctionCallTrace(true);
+ TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
// Check the defaults:
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get<int>() ), static_cast<int>( StencilFunction::ALWAYS ), TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_MASK ).Get<int>() ), 0xFF, TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE ).Get<int>() ), 0x00, TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_MASK ).Get<int>() ), 0xFF, TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL ).Get<int>() ), static_cast<int>( StencilOperation::KEEP ), TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL ).Get<int>() ), static_cast<int>( StencilOperation::KEEP ), TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS ).Get<int>() ), static_cast<int>( StencilOperation::KEEP ), TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION).Get<int>()), static_cast<int>(StencilFunction::ALWAYS), TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_MASK).Get<int>()), 0xFF, TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE).Get<int>()), 0x00, TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0xFF, TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL).Get<int>()), static_cast<int>(StencilOperation::KEEP), TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL).Get<int>()), static_cast<int>(StencilOperation::KEEP), TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS).Get<int>()), static_cast<int>(StencilOperation::KEEP), TEST_LOCATION);
END_TEST;
}
TestApplication application;
tet_infoline("Test setting the RenderMode to use the stencil buffer");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace( true );
- glAbstraction.EnableStencilFunctionCallTrace( true );
- TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
+ glAbstraction.EnableEnableDisableCallTrace(true);
+ glAbstraction.EnableStencilFunctionCallTrace(true);
+ TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
// Set the StencilFunction to something other than the default, to confirm it is set as a property,
// but NO GL call has been made while the RenderMode is set to not use the stencil buffer.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::NONE );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::NONE);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::NEVER );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get<int>() ), static_cast<int>( StencilFunction::NEVER ), TEST_LOCATION );
+ renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, StencilFunction::NEVER);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION).Get<int>()), static_cast<int>(StencilFunction::NEVER), TEST_LOCATION);
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
- std::string methodString( "StencilFunc" );
- DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
+ std::string methodString("StencilFunc");
+ DALI_TEST_CHECK(!glStencilFunctionStack.FindMethod(methodString));
// Test the other RenderModes that will not enable the stencil buffer.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::AUTO );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
- DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::AUTO);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
+ DALI_TEST_CHECK(!glStencilFunctionStack.FindMethod(methodString));
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
- DALI_TEST_CHECK( !glStencilFunctionStack.FindMethod( methodString ) );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
+ DALI_TEST_CHECK(!glStencilFunctionStack.FindMethod(methodString));
// Now set the RenderMode to modes that will use the stencil buffer, and check the StencilFunction has changed.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetStencilTestString() ) );
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethod( methodString ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetStencilTestString()));
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethod(methodString));
// Test the COLOR_STENCIL RenderMode as it also enables the stencil buffer.
// First set a mode to turn off the stencil buffer, so the enable is required.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::COLOR_STENCIL);
// Set a different stencil function as the last one is cached.
- renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, StencilFunction::ALWAYS);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- DALI_TEST_CHECK( glEnableDisableStack.FindMethodAndParams( "Enable", GetStencilTestString() ) );
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethod( methodString ) );
+ DALI_TEST_CHECK(glEnableDisableStack.FindMethodAndParams("Enable", GetStencilTestString()));
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethod(methodString));
END_TEST;
}
// Helper function for the SetRenderModeToUseColorBuffer test.
-void CheckRenderModeColorMask( TestApplication& application, Renderer& renderer, RenderMode::Type renderMode, bool expectedValue )
+void CheckRenderModeColorMask(TestApplication& application, Renderer& renderer, RenderMode::Type renderMode, bool expectedValue)
{
// Set the RenderMode property to a value that should not allow color buffer writes.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, renderMode );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, renderMode);
application.SendNotification();
application.Render();
// Check if ColorMask has been called, and that the values are correct.
- TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- const TestGlAbstraction::ColorMaskParams& colorMaskParams( glAbstraction.GetColorMaskParams() );
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
+ const TestGlAbstraction::ColorMaskParams& colorMaskParams(glAbstraction.GetColorMaskParams());
- DALI_TEST_EQUALS<bool>( colorMaskParams.red, expectedValue, TEST_LOCATION );
- DALI_TEST_EQUALS<bool>( colorMaskParams.green, expectedValue, TEST_LOCATION );
- DALI_TEST_EQUALS<bool>( colorMaskParams.blue, expectedValue, TEST_LOCATION );
- DALI_TEST_EQUALS<bool>( colorMaskParams.alpha, expectedValue, TEST_LOCATION );
+ DALI_TEST_EQUALS<bool>(colorMaskParams.red, expectedValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.green, expectedValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.blue, expectedValue, TEST_LOCATION);
+ DALI_TEST_EQUALS<bool>(colorMaskParams.alpha, expectedValue, TEST_LOCATION);
}
int UtcDaliRendererSetRenderModeToUseColorBuffer(void)
TestApplication application;
tet_infoline("Test setting the RenderMode to use the color buffer");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
// Set the RenderMode property to a value that should not allow color buffer writes.
// Then check if ColorMask has been called, and that the values are correct.
- CheckRenderModeColorMask( application, renderer, RenderMode::AUTO, true );
- CheckRenderModeColorMask( application, renderer, RenderMode::NONE, false );
- CheckRenderModeColorMask( application, renderer, RenderMode::COLOR, true );
- CheckRenderModeColorMask( application, renderer, RenderMode::STENCIL, false );
- CheckRenderModeColorMask( application, renderer, RenderMode::COLOR_STENCIL, true );
+ CheckRenderModeColorMask(application, renderer, RenderMode::AUTO, true);
+ CheckRenderModeColorMask(application, renderer, RenderMode::NONE, false);
+ CheckRenderModeColorMask(application, renderer, RenderMode::COLOR, true);
+ CheckRenderModeColorMask(application, renderer, RenderMode::STENCIL, false);
+ CheckRenderModeColorMask(application, renderer, RenderMode::COLOR_STENCIL, true);
END_TEST;
}
TestApplication application;
tet_infoline("Test setting the StencilFunction");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace( true );
- glAbstraction.EnableStencilFunctionCallTrace( true );
- TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
+ glAbstraction.EnableEnableDisableCallTrace(true);
+ glAbstraction.EnableStencilFunctionCallTrace(true);
+ TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
// RenderMode must use the stencil for StencilFunction to operate.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
/*
* Lookup table for testing StencilFunction.
* Note: This MUST be in the same order as the Dali::StencilFunction enum.
*/
const int StencilFunctionLookupTable[] = {
- GL_NEVER,
- GL_LESS,
- GL_EQUAL,
- GL_LEQUAL,
- GL_GREATER,
- GL_NOTEQUAL,
- GL_GEQUAL,
- GL_ALWAYS
- }; const int StencilFunctionLookupTableCount = sizeof( StencilFunctionLookupTable ) / sizeof( StencilFunctionLookupTable[0] );
+ GL_NEVER,
+ GL_LESS,
+ GL_EQUAL,
+ GL_LEQUAL,
+ GL_GREATER,
+ GL_NOTEQUAL,
+ GL_GEQUAL,
+ GL_ALWAYS};
+ const int StencilFunctionLookupTableCount = sizeof(StencilFunctionLookupTable) / sizeof(StencilFunctionLookupTable[0]);
/*
* Loop through all types of StencilFunction, checking:
* - Checks the correct parameters to "glStencilFunc" were used
*/
std::string nonChangingParameters = "0, 255";
- std::string methodString( "StencilFunc" );
- for( int i = 0; i < StencilFunctionLookupTableCount; ++i )
+ std::string methodString("StencilFunc");
+ for(int i = 0; i < StencilFunctionLookupTableCount; ++i)
{
// Set the property.
- renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION, static_cast<Dali::StencilFunction::Type>( i ) );
+ renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION, static_cast<Dali::StencilFunction::Type>(i));
// Check GetProperty returns the same value.
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION ).Get<int>() ), i, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION).Get<int>()), i, TEST_LOCATION);
// Reset the trace debug.
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
// Check the function is called and the parameters are correct.
std::stringstream parameterStream;
- parameterStream << StencilFunctionLookupTable[ i ] << ", " << nonChangingParameters;
+ parameterStream << StencilFunctionLookupTable[i] << ", " << nonChangingParameters;
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) );
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
}
// Change the Function Reference only and check the behavior is correct:
// 170 is 0xaa in hex / 10101010 in binary (every other bit set).
int testValueReference = 170;
- renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE, testValueReference );
+ renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE, testValueReference);
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE ).Get<int>() ), testValueReference, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE).Get<int>()), testValueReference, TEST_LOCATION);
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetCurrentProperty( Renderer::Property::STENCIL_FUNCTION_REFERENCE ).Get<int>() ), testValueReference, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_FUNCTION_REFERENCE).Get<int>()), testValueReference, TEST_LOCATION);
std::stringstream parameterStream;
- parameterStream << StencilFunctionLookupTable[ StencilOperation::DECREMENT_WRAP ] << ", " << testValueReference << ", 255";
-
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) );
+ parameterStream << StencilFunctionLookupTable[StencilOperation::DECREMENT_WRAP] << ", " << testValueReference << ", 255";
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
// Change the Function Mask only and check the behavior is correct:
// 85 is 0x55 in hex / 01010101 in binary (every other bit set).
int testValueMask = 85;
- renderer.SetProperty( Renderer::Property::STENCIL_FUNCTION_MASK, testValueMask );
+ renderer.SetProperty(Renderer::Property::STENCIL_FUNCTION_MASK, testValueMask);
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_FUNCTION_MASK ).Get<int>() ), testValueMask, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_FUNCTION_MASK).Get<int>()), testValueMask, TEST_LOCATION);
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetCurrentProperty( Renderer::Property::STENCIL_FUNCTION_MASK ).Get<int>() ), testValueMask, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_FUNCTION_MASK).Get<int>()), testValueMask, TEST_LOCATION);
// Clear the stringstream.
- parameterStream.str( std::string() );
- parameterStream << StencilFunctionLookupTable[ StencilOperation::DECREMENT_WRAP ] << ", " << testValueReference << ", " << testValueMask;
+ parameterStream.str(std::string());
+ parameterStream << StencilFunctionLookupTable[StencilOperation::DECREMENT_WRAP] << ", " << testValueReference << ", " << testValueMask;
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) );
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
END_TEST;
}
TestApplication application;
tet_infoline("Test setting the StencilOperation");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace( true );
- glAbstraction.EnableStencilFunctionCallTrace( true );
- TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
+ glAbstraction.EnableEnableDisableCallTrace(true);
+ glAbstraction.EnableStencilFunctionCallTrace(true);
+ TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
// RenderMode must use the stencil for StencilOperation to operate.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
/*
* Lookup table for testing StencilOperation.
GL_DECR,
GL_INVERT,
GL_INCR_WRAP,
- GL_DECR_WRAP
- }; const int StencilOperationLookupTableCount = sizeof( StencilOperationLookupTable ) / sizeof( StencilOperationLookupTable[0] );
+ GL_DECR_WRAP};
+ const int StencilOperationLookupTableCount = sizeof(StencilOperationLookupTable) / sizeof(StencilOperationLookupTable[0]);
// Set all 3 StencilOperation properties to a default.
- renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP );
- renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::ZERO );
- renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::ZERO );
+ renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL, StencilOperation::KEEP);
+ renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, StencilOperation::ZERO);
+ renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, StencilOperation::ZERO);
// Set our expected parameter list to the equivalent result.
- int parameters[] = { StencilOperationLookupTable[ StencilOperation::ZERO ], StencilOperationLookupTable[ StencilOperation::ZERO ], StencilOperationLookupTable[ StencilOperation::ZERO ] };
+ int parameters[] = {StencilOperationLookupTable[StencilOperation::ZERO], StencilOperationLookupTable[StencilOperation::ZERO], StencilOperationLookupTable[StencilOperation::ZERO]};
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
/*
* Loop through all types of StencilOperation, checking:
* - Checks the correct parameters to "glStencilFunc" were used
* - Checks the above for all 3 parameter placements of StencilOperation ( OnFail, OnZFail, OnPass )
*/
- std::string methodString( "StencilOp" );
+ std::string methodString("StencilOp");
- for( int i = 0; i < StencilOperationLookupTableCount; ++i )
+ for(int i = 0; i < StencilOperationLookupTableCount; ++i)
{
- for( int j = 0; j < StencilOperationLookupTableCount; ++j )
+ for(int j = 0; j < StencilOperationLookupTableCount; ++j)
{
- for( int k = 0; k < StencilOperationLookupTableCount; ++k )
+ for(int k = 0; k < StencilOperationLookupTableCount; ++k)
{
// Set the property (outer loop causes all 3 different properties to be set separately).
- renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL, static_cast<Dali::StencilFunction::Type>( i ) );
- renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, static_cast<Dali::StencilFunction::Type>( j ) );
- renderer.SetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, static_cast<Dali::StencilFunction::Type>( k ) );
+ renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL, static_cast<Dali::StencilFunction::Type>(i));
+ renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL, static_cast<Dali::StencilFunction::Type>(j));
+ renderer.SetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS, static_cast<Dali::StencilFunction::Type>(k));
// Check GetProperty returns the same value.
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_FAIL ).Get<int>() ), i, TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL ).Get<int>() ), j, TEST_LOCATION );
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_OPERATION_ON_Z_PASS ).Get<int>() ), k, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_FAIL).Get<int>()), i, TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL).Get<int>()), j, TEST_LOCATION);
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_OPERATION_ON_Z_PASS).Get<int>()), k, TEST_LOCATION);
// Reset the trace debug.
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
// Check the function is called and the parameters are correct.
// Set the expected parameter value at its correct index (only)
- parameters[ 0u ] = StencilOperationLookupTable[ i ];
- parameters[ 1u ] = StencilOperationLookupTable[ j ];
- parameters[ 2u ] = StencilOperationLookupTable[ k ];
+ parameters[0u] = StencilOperationLookupTable[i];
+ parameters[1u] = StencilOperationLookupTable[j];
+ parameters[2u] = StencilOperationLookupTable[k];
// Build the parameter list.
std::stringstream parameterStream;
- for( int parameterBuild = 0; parameterBuild < 3; ++parameterBuild )
+ for(int parameterBuild = 0; parameterBuild < 3; ++parameterBuild)
{
- parameterStream << parameters[ parameterBuild ];
+ parameterStream << parameters[parameterBuild];
// Comma-separate the parameters.
- if( parameterBuild < 2 )
+ if(parameterBuild < 2)
{
parameterStream << ", ";
}
}
// Check the function was called and the parameters were correct.
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterStream.str() ) );
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterStream.str()));
}
}
}
TestApplication application;
tet_infoline("Test setting the StencilMask");
- Renderer renderer = RendererTestFixture( application );
+ Renderer renderer = RendererTestFixture(application);
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- glAbstraction.EnableEnableDisableCallTrace( true );
- glAbstraction.EnableStencilFunctionCallTrace( true );
- TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
+ glAbstraction.EnableEnableDisableCallTrace(true);
+ glAbstraction.EnableStencilFunctionCallTrace(true);
+ TraceCallStack& glEnableDisableStack = glAbstraction.GetEnableDisableTrace();
TraceCallStack& glStencilFunctionStack = glAbstraction.GetStencilFunctionTrace();
// RenderMode must use the stencil for StencilMask to operate.
- renderer.SetProperty( Renderer::Property::RENDER_MODE, RenderMode::STENCIL );
+ renderer.SetProperty(Renderer::Property::RENDER_MODE, RenderMode::STENCIL);
// Set the StencilMask property to a value.
- renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0x00 );
+ renderer.SetProperty(Renderer::Property::STENCIL_MASK, 0x00);
// Check GetProperty returns the same value.
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_MASK ).Get<int>() ), 0x00, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0x00, TEST_LOCATION);
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetCurrentProperty( Renderer::Property::STENCIL_MASK ).Get<int>() ), 0x00, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0x00, TEST_LOCATION);
- std::string methodString( "StencilMask" );
+ std::string methodString("StencilMask");
std::string parameterString = "0";
// Check the function was called and the parameters were correct.
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterString ) );
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterString));
// Set the StencilMask property to another value to ensure it has changed.
- renderer.SetProperty( Renderer::Property::STENCIL_MASK, 0xFF );
+ renderer.SetProperty(Renderer::Property::STENCIL_MASK, 0xFF);
// Check GetProperty returns the same value.
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetProperty( Renderer::Property::STENCIL_MASK ).Get<int>() ), 0xFF, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0xFF, TEST_LOCATION);
- ResetDebugAndFlush( application, glEnableDisableStack, glStencilFunctionStack );
+ ResetDebugAndFlush(application, glEnableDisableStack, glStencilFunctionStack);
- DALI_TEST_EQUALS<int>( static_cast<int>( renderer.GetCurrentProperty( Renderer::Property::STENCIL_MASK ).Get<int>() ), 0xFF, TEST_LOCATION );
+ DALI_TEST_EQUALS<int>(static_cast<int>(renderer.GetCurrentProperty(Renderer::Property::STENCIL_MASK).Get<int>()), 0xFF, TEST_LOCATION);
parameterString = "255";
// Check the function was called and the parameters were correct.
- DALI_TEST_CHECK( glStencilFunctionStack.FindMethodAndParams( methodString, parameterString ) );
+ DALI_TEST_CHECK(glStencilFunctionStack.FindMethodAndParams(methodString, parameterString));
END_TEST;
}
//Create a TextureSet with 4 textures (One more texture in the texture set than active samplers)
//@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform()
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 64u, 64u );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64u, 64u);
TextureSet textureSet = CreateTextureSet();
- textureSet.SetTexture(0, texture );
- textureSet.SetTexture(1, texture );
- textureSet.SetTexture(2, texture );
- textureSet.SetTexture(3, texture );
- Shader shader = Shader::New("VertexSource", "FragmentSource");
+ textureSet.SetTexture(0, texture);
+ textureSet.SetTexture(1, texture);
+ textureSet.SetTexture(2, texture);
+ textureSet.SetTexture(3, texture);
+ Shader shader = Shader::New("VertexSource", "FragmentSource");
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
- Actor actor= Actor::New();
+ Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::POSITION, Vector2(0.0f,0.0f));
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
+ actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
application.GetScene().Add(actor);
- TestGlAbstraction& gl = application.GetGlAbstraction();
- TraceCallStack& drawTrace = gl.GetDrawTrace();
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ TraceCallStack& drawTrace = gl.GetDrawTrace();
drawTrace.Reset();
drawTrace.Enable(true);
application.Render(0);
//Test we do the drawcall when TextureSet has more textures than there are active samplers in the shader
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
//Create a TextureSet with 1 texture (two more active samplers than texture in the texture set)
//@note Shaders in the test suit have 3 active samplers. See TestGlAbstraction::GetActiveUniform()
textureSet = CreateTextureSet();
- renderer.SetTextures( textureSet );
- textureSet.SetTexture(0, texture );
+ renderer.SetTextures(textureSet);
+ textureSet.SetTexture(0, texture);
drawTrace.Reset();
application.SendNotification();
application.Render(0);
//Test we do the drawcall when TextureSet has less textures than there are active samplers in the shader.
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Test OPACITY property" );
+ tet_infoline("Test OPACITY property");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) );
- application.GetScene().Add( actor );
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+ application.GetScene().Add(actor);
- Property::Value value = renderer.GetProperty( DevelRenderer::Property::OPACITY );
- float opacity;
- DALI_TEST_CHECK( value.Get( opacity ) );
- DALI_TEST_EQUALS( opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ Property::Value value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
+ float opacity;
+ DALI_TEST_CHECK(value.Get(opacity));
+ DALI_TEST_EQUALS(opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
application.SendNotification();
application.Render();
- Vector4 actualValue;
+ Vector4 actualValue;
TestGlAbstraction& gl = application.GetGlAbstraction();
- DALI_TEST_CHECK( gl.GetUniformValue< Vector4 >( "uColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue.a, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
+ DALI_TEST_EQUALS(actualValue.a, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- renderer.SetProperty( DevelRenderer::Property::OPACITY, 0.5f );
+ renderer.SetProperty(DevelRenderer::Property::OPACITY, 0.5f);
application.SendNotification();
application.Render();
- value = renderer.GetProperty( DevelRenderer::Property::OPACITY );
- DALI_TEST_CHECK( value.Get( opacity ) );
- DALI_TEST_EQUALS( opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
+ DALI_TEST_CHECK(value.Get(opacity));
+ DALI_TEST_EQUALS(opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- value = renderer.GetCurrentProperty( DevelRenderer::Property::OPACITY );
- DALI_TEST_CHECK( value.Get( opacity ) );
- DALI_TEST_EQUALS( opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ value = renderer.GetCurrentProperty(DevelRenderer::Property::OPACITY);
+ DALI_TEST_CHECK(value.Get(opacity));
+ DALI_TEST_EQUALS(opacity, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- DALI_TEST_CHECK( gl.GetUniformValue< Vector4 >( "uColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue.a, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uColor", actualValue));
+ DALI_TEST_EQUALS(actualValue.a, 0.5f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Test OPACITY property animation" );
+ tet_infoline("Test OPACITY property animation");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) );
- application.GetScene().Add( actor );
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- Property::Value value = renderer.GetProperty( DevelRenderer::Property::OPACITY );
- float opacity;
- DALI_TEST_CHECK( value.Get( opacity ) );
- DALI_TEST_EQUALS( opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ Property::Value value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
+ float opacity;
+ DALI_TEST_CHECK(value.Get(opacity));
+ DALI_TEST_EQUALS(opacity, 1.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( renderer, DevelRenderer::Property::OPACITY ), 0.0f );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(renderer, DevelRenderer::Property::OPACITY), 0.0f);
animation.Play();
application.SendNotification();
- application.Render( 1000 );
+ application.Render(1000);
- value = renderer.GetProperty( DevelRenderer::Property::OPACITY );
- DALI_TEST_CHECK( value.Get( opacity ) );
- DALI_TEST_EQUALS( opacity, 0.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
+ DALI_TEST_CHECK(value.Get(opacity));
+ DALI_TEST_EQUALS(opacity, 0.0f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
// Need to clear the animation before setting the property as the animation value is baked and will override any previous setters
animation.Clear();
- renderer.SetProperty( DevelRenderer::Property::OPACITY, 0.1f );
+ renderer.SetProperty(DevelRenderer::Property::OPACITY, 0.1f);
- animation.AnimateBy( Property( renderer, DevelRenderer::Property::OPACITY ), 0.5f );
+ animation.AnimateBy(Property(renderer, DevelRenderer::Property::OPACITY), 0.5f);
animation.Play();
application.SendNotification();
- application.Render( 1000 );
+ application.Render(1000);
- value = renderer.GetProperty( DevelRenderer::Property::OPACITY );
- DALI_TEST_CHECK( value.Get( opacity ) );
- DALI_TEST_EQUALS( opacity, 0.6f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
- DALI_TEST_EQUALS( opacity, renderer.GetCurrentProperty( DevelRenderer::Property::OPACITY ).Get< float >(), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION );
+ value = renderer.GetProperty(DevelRenderer::Property::OPACITY);
+ DALI_TEST_CHECK(value.Get(opacity));
+ DALI_TEST_EQUALS(opacity, 0.6f, Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
+ DALI_TEST_EQUALS(opacity, renderer.GetCurrentProperty(DevelRenderer::Property::OPACITY).Get<float>(), Dali::Math::MACHINE_EPSILON_1, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Test invalid property" );
+ tet_infoline("Test invalid property");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- application.GetScene().Add( actor );
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- Property::Value value = renderer.GetProperty( Renderer::Property::DEPTH_INDEX + 100 );
- DALI_TEST_CHECK( value.GetType() == Property::Type::NONE );
+ Property::Value value = renderer.GetProperty(Renderer::Property::DEPTH_INDEX + 100);
+ DALI_TEST_CHECK(value.GetType() == Property::Type::NONE);
- value = renderer.GetCurrentProperty( Renderer::Property::DEPTH_INDEX + 100 );
- DALI_TEST_CHECK( value.GetType() == Property::Type::NONE );
+ value = renderer.GetCurrentProperty(Renderer::Property::DEPTH_INDEX + 100);
+ DALI_TEST_CHECK(value.GetType() == Property::Type::NONE);
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Test RENDERING_BEHAVIOR property" );
+ tet_infoline("Test RENDERING_BEHAVIOR property");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) );
- application.GetScene().Add( actor );
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+ application.GetScene().Add(actor);
- Property::Value value = renderer.GetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR );
- int renderingBehavior;
- DALI_TEST_CHECK( value.Get( renderingBehavior ) );
- DALI_TEST_EQUALS( static_cast< DevelRenderer::Rendering::Type >( renderingBehavior ), DevelRenderer::Rendering::IF_REQUIRED, TEST_LOCATION );
+ Property::Value value = renderer.GetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR);
+ int renderingBehavior;
+ DALI_TEST_CHECK(value.Get(renderingBehavior));
+ DALI_TEST_EQUALS(static_cast<DevelRenderer::Rendering::Type>(renderingBehavior), DevelRenderer::Rendering::IF_REQUIRED, TEST_LOCATION);
application.SendNotification();
application.Render();
uint32_t updateStatus = application.GetUpdateStatus();
- DALI_TEST_CHECK( !( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ) );
+ DALI_TEST_CHECK(!(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING));
- renderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY );
+ renderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::CONTINUOUSLY);
- value = renderer.GetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR );
- DALI_TEST_CHECK( value.Get( renderingBehavior ) );
- DALI_TEST_EQUALS( static_cast< DevelRenderer::Rendering::Type >( renderingBehavior ), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION );
+ value = renderer.GetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR);
+ DALI_TEST_CHECK(value.Get(renderingBehavior));
+ DALI_TEST_EQUALS(static_cast<DevelRenderer::Rendering::Type>(renderingBehavior), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION);
// Render and check the update status
application.SendNotification();
updateStatus = application.GetUpdateStatus();
- DALI_TEST_CHECK( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING );
+ DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
- value = renderer.GetCurrentProperty( DevelRenderer::Property::RENDERING_BEHAVIOR );
- DALI_TEST_CHECK( value.Get( renderingBehavior ) );
- DALI_TEST_EQUALS( static_cast< DevelRenderer::Rendering::Type >( renderingBehavior ), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION );
+ value = renderer.GetCurrentProperty(DevelRenderer::Property::RENDERING_BEHAVIOR);
+ DALI_TEST_CHECK(value.Get(renderingBehavior));
+ DALI_TEST_EQUALS(static_cast<DevelRenderer::Rendering::Type>(renderingBehavior), DevelRenderer::Rendering::CONTINUOUSLY, TEST_LOCATION);
// Render again and check the update status
application.SendNotification();
updateStatus = application.GetUpdateStatus();
- DALI_TEST_CHECK( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING );
+ DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
// Change rendering behavior
- renderer.SetProperty( DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED );
+ renderer.SetProperty(DevelRenderer::Property::RENDERING_BEHAVIOR, DevelRenderer::Rendering::IF_REQUIRED);
// Render and check the update status
application.SendNotification();
updateStatus = application.GetUpdateStatus();
- DALI_TEST_CHECK( !( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING ) );
+ DALI_TEST_CHECK(!(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING));
END_TEST;
}
{
TestApplication application;
- tet_infoline( "Test regenerating uniform map when attaching renderer to the node" );
+ tet_infoline("Test regenerating uniform map when attaching renderer to the node");
Geometry geometry = CreateQuadGeometry();
- Shader shader = Shader::New( "vertexSrc", "fragmentSrc" );
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = Shader::New("vertexSrc", "fragmentSrc");
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- actor.SetProperty( Actor::Property::COLOR, Vector4( 1.0f, 0.0f, 1.0f, 1.0f ) );
- application.GetScene().Add( actor );
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ actor.SetProperty(Actor::Property::COLOR, Vector4(1.0f, 0.0f, 1.0f, 1.0f));
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- actor.RemoveRenderer( renderer );
- shader = Shader::New( "vertexSrc", "fragmentSrc" );
- shader.RegisterProperty( "opacity", 0.5f );
- renderer.SetShader( shader );
+ actor.RemoveRenderer(renderer);
+ shader = Shader::New("vertexSrc", "fragmentSrc");
+ shader.RegisterProperty("opacity", 0.5f);
+ renderer.SetShader(shader);
- Stage::GetCurrent().KeepRendering( 1.0f );
+ Stage::GetCurrent().KeepRendering(1.0f);
// Update for several frames
application.SendNotification();
application.Render();
// Add Renderer
- actor.AddRenderer( renderer );
+ actor.AddRenderer(renderer);
application.SendNotification();
application.Render();
// Nothing to test here, the test must not crash
auto updateStatus = application.GetUpdateStatus();
- DALI_TEST_CHECK( updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING );
+ DALI_TEST_CHECK(updateStatus & Integration::KeepUpdating::STAGE_KEEP_RENDERING);
END_TEST;
}
tet_infoline("Test adding draw commands to the renderer");
- TestGlAbstraction &glAbstraction = application.GetGlAbstraction();
+ TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
glAbstraction.EnableEnableDisableCallTrace(true);
Geometry geometry = CreateQuadGeometry();
Shader shader = Shader::New("vertexSrc", "fragmentSrc");
Renderer renderer = Renderer::New(geometry, shader);
- renderer.SetProperty( Renderer::Property::BLEND_MODE, Dali::BlendMode::ON );
+ renderer.SetProperty(Renderer::Property::BLEND_MODE, Dali::BlendMode::ON);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
// Expect delivering a single draw call
- auto &drawTrace = glAbstraction.GetDrawTrace();
+ auto& drawTrace = glAbstraction.GetDrawTrace();
drawTrace.Reset();
drawTrace.Enable(true);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(drawTrace.CountMethod("DrawElements"), 1, TEST_LOCATION);
- auto drawCommand1 = DevelRenderer::DrawCommand{};
+ auto drawCommand1 = DevelRenderer::DrawCommand{};
drawCommand1.drawType = DevelRenderer::DrawType::INDEXED;
drawCommand1.firstIndex = 0;
drawCommand1.elementCount = 2;
drawCommand1.queue = DevelRenderer::RENDER_QUEUE_OPAQUE;
- auto drawCommand2 = DevelRenderer::DrawCommand{};
+ auto drawCommand2 = DevelRenderer::DrawCommand{};
drawCommand2.drawType = DevelRenderer::DrawType::INDEXED;
drawCommand2.firstIndex = 2;
drawCommand2.elementCount = 2;
drawCommand2.queue = DevelRenderer::RENDER_QUEUE_TRANSPARENT;
- auto drawCommand3 = DevelRenderer::DrawCommand{};
+ auto drawCommand3 = DevelRenderer::DrawCommand{};
drawCommand3.drawType = DevelRenderer::DrawType::ARRAY;
drawCommand3.firstIndex = 2;
drawCommand3.elementCount = 2;
int UtcDaliRendererSetGeometryNegative(void)
{
TestApplication application;
- Dali::Renderer instance;
+ Dali::Renderer instance;
try
{
Dali::Geometry arg1;
int UtcDaliRendererSetTexturesNegative(void)
{
TestApplication application;
- Dali::Renderer instance;
+ Dali::Renderer instance;
try
{
Dali::TextureSet arg1;
int UtcDaliRendererSetShaderNegative(void)
{
TestApplication application;
- Dali::Renderer instance;
+ Dali::Renderer instance;
try
{
Dali::Shader arg1;
int UtcDaliRendererGetGeometryNegative(void)
{
TestApplication application;
- Dali::Renderer instance;
+ Dali::Renderer instance;
try
{
instance.GetGeometry();
int UtcDaliRendererGetTexturesNegative(void)
{
TestApplication application;
- Dali::Renderer instance;
+ Dali::Renderer instance;
try
{
instance.GetTextures();
int UtcDaliRendererGetShaderNegative(void)
{
TestApplication application;
- Dali::Renderer instance;
+ Dali::Renderer instance;
try
{
instance.GetShader();
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
#include <test-touch-event-utils.h>
+#include <iostream>
+
using namespace Dali;
void utc_dali_rotation_gesture_detector_startup(void)
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
rotatedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
RotationGesture receivedGesture;
- Actor rotatedActor;
+ Actor rotatedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const RotationGesture& rotation)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = rotation;
- signalData.rotatedActor = actor;
+ signalData.rotatedActor = actor;
}
void operator()()
// Functor that removes the gestured actor from stage
struct UnstageActorFunctor : public GestureReceivedFunctor
{
- UnstageActorFunctor( SignalData& data, GestureState& stateToUnstage, Integration::Scene scene )
- : GestureReceivedFunctor( data ),
- stateToUnstage( stateToUnstage ),
- scene( scene )
+ UnstageActorFunctor(SignalData& data, GestureState& stateToUnstage, Integration::Scene scene)
+ : GestureReceivedFunctor(data),
+ stateToUnstage(stateToUnstage),
+ scene(scene)
{
}
- void operator()( Actor actor, const RotationGesture& rotation )
+ void operator()(Actor actor, const RotationGesture& rotation)
{
- GestureReceivedFunctor::operator()( actor, rotation );
+ GestureReceivedFunctor::operator()(actor, rotation);
- if ( rotation.GetState() == stateToUnstage )
+ if(rotation.GetState() == stateToUnstage)
{
- scene.Remove( actor );
+ scene.Remove(actor);
}
}
- GestureState& stateToUnstage;
+ GestureState& stateToUnstage;
Integration::Scene scene;
};
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
{
TestApplication application;
- RotationGestureDetector detector = RotationGestureDetector::New();;
+ RotationGestureDetector detector = RotationGestureDetector::New();
+ ;
- RotationGestureDetector copy( detector );
- DALI_TEST_CHECK( detector );
+ RotationGestureDetector copy(detector);
+ DALI_TEST_CHECK(detector);
END_TEST;
}
{
TestApplication application;
- RotationGestureDetector detector = RotationGestureDetector::New();;
+ RotationGestureDetector detector = RotationGestureDetector::New();
+ ;
RotationGestureDetector assign;
assign = detector;
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(detector);
- DALI_TEST_CHECK( detector == assign );
+ DALI_TEST_CHECK(detector == assign);
END_TEST;
}
// Attach an actor and emit a touch event on the actor to ensure complete line coverage
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
Integration::TouchEvent touchEvent(1);
- Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 20.0f, 20.0f ) );
+ Integration::Point point;
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(20.0f, 20.0f));
touchEvent.AddPoint(point);
application.ProcessEvent(touchEvent);
Integration::Point point2;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 20.0f, 20.0f ) );
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(20.0f, 20.0f));
touchEvent.AddPoint(point2);
application.ProcessEvent(touchEvent);
END_TEST;
RotationGestureDetector detector2 = RotationGestureDetector::DownCast(object);
DALI_TEST_CHECK(detector2);
- RotationGestureDetector detector3 = DownCast< RotationGestureDetector >(object);
+ RotationGestureDetector detector3 = DownCast<RotationGestureDetector>(object);
DALI_TEST_CHECK(detector3);
- BaseHandle unInitializedObject;
+ BaseHandle unInitializedObject;
RotationGestureDetector detector4 = RotationGestureDetector::DownCast(unInitializedObject);
DALI_TEST_CHECK(!detector4);
- RotationGestureDetector detector5 = DownCast< RotationGestureDetector >(unInitializedObject);
+ RotationGestureDetector detector5 = DownCast<RotationGestureDetector>(unInitializedObject);
DALI_TEST_CHECK(!detector5);
- GestureDetector detector6 = RotationGestureDetector::New();
+ GestureDetector detector6 = RotationGestureDetector::New();
RotationGestureDetector detector7 = RotationGestureDetector::DownCast(detector6);
DALI_TEST_CHECK(detector7);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do a rotation outside actor's area
- TestStartRotation( application, Vector2( 112.0f, 62.0f ), Vector2( 112.0f, 162.0f ),
- Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ), 100 );
+ TestStartRotation(application, Vector2(112.0f, 62.0f), Vector2(112.0f, 162.0f), Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), 100);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Continue rotation into actor's area - we should still not receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ),
- Vector2( 5.0f, 5.0f ), Vector2( 35.0f, 35.0f ), 200 );
+ TestContinueRotation(application, Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), Vector2(5.0f, 5.0f), Vector2(35.0f, 35.0f), 200);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Stop rotating - we should still not receive the signal
data.Reset();
- TestEndRotation( application, Vector2( 6.0f, 6.0f ), Vector2( 18.0f, 18.0f ),
- Vector2( 10.0f, 8.0f ), Vector2( 14.0f, 16.0f ), 300 );
+ TestEndRotation(application, Vector2(6.0f, 6.0f), Vector2(18.0f, 18.0f), Vector2(10.0f, 8.0f), Vector2(14.0f, 16.0f), 300);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start rotation within the actor's area
- TestStartRotation( application, Vector2( 5.0f, 5.0f ), Vector2( 20.0f, 20.0f ),
- Vector2( 5.0f, 5.0f ), Vector2( 20.0f, 30.0f ), 100 );
+ TestStartRotation(application, Vector2(5.0f, 5.0f), Vector2(20.0f, 20.0f), Vector2(5.0f, 5.0f), Vector2(20.0f, 30.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.244f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
// Continue the rotation within the actor's area - we should still receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 17.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 400 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(17.0f, 20.0f), Vector2(25.0f, 20.0f), 400);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(-0.785398f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
// Rotation Gesture leaves actor's area - we should still receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 17.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 300.0f, 10.0f ), Vector2( 340.0f, 10.0f ), 1000 );
+ TestContinueRotation(application, Vector2(17.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(300.0f, 10.0f), Vector2(340.0f, 10.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(-0.785398f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
// Gesture ends - we would receive a finished state
data.Reset();
- TestEndRotation( application, Vector2( 300.0f, 10.0f ), Vector2( 340.0f, 10.0f ),
- Vector2( 305.0f, 10.0f ), Vector2( 315.0f, 10.0f ), 1500);
+ TestEndRotation(application, Vector2(300.0f, 10.0f), Vector2(340.0f, 10.0f), Vector2(305.0f, 10.0f), Vector2(315.0f, 10.0f), 1500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(-0.785398f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start rotation within the actor's area
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 31.0f, 29.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(31.0f, 29.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(0.404892f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
// Continue the rotation within the actor's area - we should still receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 29.0f, 15.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(29.0f, 15.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(-0.343024f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
// Gesture ends within actor's area - we would receive a finished state
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 29.0f, 15.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(29.0f, 15.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(-0.463648f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start rotation within the actor's area
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
-
// Continue the rotation within the actor's area - we should still receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::FINISHED, data.receivedGesture.GetState(), TEST_LOCATION);
// Ensure we are no longer signalled
data.Reset();
- TestGenerateRotation( application );
+ TestGenerateRotation(application);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start rotation within the actor's area
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the rotation within the actor's area - we should still receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
// Attach a temporary actor to stop detector being removed from RotationGestureProcessor when main actor
// is destroyed.
Actor tempActor = Actor::New();
- tempActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- tempActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
+ tempActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ tempActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.GetScene().Add(tempActor);
detector.Attach(tempActor);
// Actor lifetime is scoped
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
// Start rotation within the actor's area
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the rotation within the actor's area - we should still receive the signal
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// Gesture ends within the area where the actor used to be
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
application.GetScene().Add(actor);
// Render and notify a couple of times
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do an entire rotation, only check finished value
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 27.0f, 15.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(27.0f, 15.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(-0.558599f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(23.0f, 17.5f), data.receivedGesture.GetScreenCenterPoint(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(67.5f, 27.0f), data.receivedGesture.GetLocalCenterPoint(), 0.01f, TEST_LOCATION);
// Rotate actor again and render and notify
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do an entire rotation, only check finished value
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 2100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 2100);
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 27.0f, 15.0f ), 3000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(27.0f, 15.0f), 3000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(-0.558599f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(23.0f, 17.5f), data.receivedGesture.GetScreenCenterPoint(), 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(27.0f, 32.5f), data.receivedGesture.GetLocalCenterPoint(), 0.01f, TEST_LOCATION);
// Rotate actor again and render and notify
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(270.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(270.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do an entire rotation, only check finished value
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 4100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 4100);
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 27.0f, 15.0f ), 5000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(27.0f, 15.0f), 5000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(-0.558599f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(23.0f, 17.5f), data.receivedGesture.GetScreenCenterPoint(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
// Set child to completely cover parent.
// Change rotation of child to be different from parent so that we can check if our local coordinate
// conversion of the parent actor is correct.
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- child.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
parent.Add(child);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do an entire pan, only check finished value - hits child area but parent should still receive it
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 29.0f, 25.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(29.0f, 25.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, parent == data.rotatedActor, TEST_LOCATION);
DALI_TEST_EQUALS(0.463648f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
detector.Detach(parent);
// Do an entire pan, only check finished value
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 2100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 2100);
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 29.0f, 35.0f ), 3000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(29.0f, 35.0f), 3000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, child == data.rotatedActor, TEST_LOCATION);
DALI_TEST_EQUALS(0.982794f, data.receivedGesture.GetRotation().radian, 0.01f, TEST_LOCATION);
TestApplication application;
Actor first = Actor::New();
- first.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- first.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(first);
Actor second = Actor::New();
- second.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- second.SetProperty( Actor::Property::POSITION_X, 100.0f);
- second.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ second.SetProperty(Actor::Property::POSITION_X, 100.0f);
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(second);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start rotation within second actor's area
- TestStartRotation( application, Vector2( 102.0f, 20.0f ), Vector2( 138.0f, 20.0f ),
- Vector2( 110.0f, 20.0f ), Vector2( 130.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(102.0f, 20.0f), Vector2(138.0f, 20.0f), Vector2(110.0f, 20.0f), Vector2(130.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.rotatedActor, TEST_LOCATION);
// Rotation moves into first actor's area - second actor should receive the rotation
data.Reset();
- TestContinueRotation( application, Vector2( 110.0f, 20.0f ), Vector2( 130.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(110.0f, 20.0f), Vector2(130.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.rotatedActor, TEST_LOCATION);
// Gesture ends within actor's area
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 119.0f, 20.0f ), Vector2( 121.0f, 20.0f ), 3000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(119.0f, 20.0f), Vector2(121.0f, 20.0f), 3000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start rotation in actor's area
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Rotation continues within actor's area
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Actor become invisible - actor should not receive the next rotation
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// Render and notify
application.SendNotification();
// Gesture ends within actor's area
data.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 3000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 3000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
application.GetScene().Add(actor2);
// Render and notify
application.Render();
// Attach actor to one detector
- SignalData firstData;
- GestureReceivedFunctor firstFunctor(firstData);
+ SignalData firstData;
+ GestureReceivedFunctor firstFunctor(firstData);
RotationGestureDetector firstDetector = RotationGestureDetector::New();
firstDetector.Attach(actor);
firstDetector.DetectedSignal().Connect(&application, firstFunctor);
// Attach actor to another detector
- SignalData secondData;
- GestureReceivedFunctor secondFunctor(secondData);
+ SignalData secondData;
+ GestureReceivedFunctor secondFunctor(secondData);
RotationGestureDetector secondDetector = RotationGestureDetector::New();
secondDetector.Attach(actor);
secondDetector.DetectedSignal().Connect(&application, secondFunctor);
secondDetector.Attach(actor2);
// Rotation in actor's area - both detector's functors should be called
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
// Rotation continues in actor's area - both detector's functors should be called
firstData.Reset();
secondData.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
firstDetector.Detach(actor);
firstData.Reset();
secondData.Reset();
- TestEndRotation( application, Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
// New rotation on actor, only secondDetector has actor attached
firstData.Reset();
secondData.Reset();
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 1500 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 1500);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
secondDetector.Detach(actor);
firstData.Reset();
secondData.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 2000 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 2000);
DALI_TEST_EQUALS(false, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(false, secondData.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor1 = Actor::New();
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor1);
- SignalData data1;
- GestureReceivedFunctor functor1(data1);
+ SignalData data1;
+ GestureReceivedFunctor functor1(data1);
RotationGestureDetector detector1 = RotationGestureDetector::New();
detector1.Attach(actor1);
detector1.DetectedSignal().Connect(&application, functor1);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::BOTTOM_RIGHT);
- actor2.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::BOTTOM_RIGHT);
+ actor2.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::BOTTOM_RIGHT);
application.GetScene().Add(actor2);
- SignalData data2;
- GestureReceivedFunctor functor2(data2);
+ SignalData data2;
+ GestureReceivedFunctor functor2(data2);
RotationGestureDetector detector2 = RotationGestureDetector::New();
detector2.Attach(actor2);
detector2.DetectedSignal().Connect(&application, functor2);
application.Render();
// Start pan in actor1's area, only data1 should be set
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data1.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
RotationGestureDetector detector = RotationGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit signals
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
stateToUnstage = GestureState::CONTINUING;
// Emit signals
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
stateToUnstage = GestureState::FINISHED;
// Emit signals
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- tet_result( TET_PASS ); // If we get here then we have handled actor stage removal gracefully.
+ tet_result(TET_PASS); // If we get here then we have handled actor stage removal gracefully.
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Create and add a second actor so that GestureDetector destruction does not come into play.
- Actor dummyActor( Actor::New() );
- dummyActor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- dummyActor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
- dummyActor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ Actor dummyActor(Actor::New());
+ dummyActor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
+ dummyActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(dummyActor);
// Render and notify
application.Render();
// State to remove actor in.
- GestureState stateToUnstage( GestureState::STARTED );
+ GestureState stateToUnstage(GestureState::STARTED);
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, stateToUnstage, application.GetScene() );
+ SignalData data;
+ UnstageActorFunctor functor(data, stateToUnstage, application.GetScene());
RotationGestureDetector detector = RotationGestureDetector::New();
detector.Attach(actor);
detector.Attach(dummyActor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Here we are testing a STARTED actor which is removed in the STARTED callback, but then added back
// before we get a continuing state. As we were removed from the stage, even if we're at the same
// position, we should still not be signalled.
// Emit signals
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Here we delete an actor in started, we should not receive any subsequent signalling.
// Emit signals
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 1500 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 1500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
application.Render();
// Continue signal emission
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 2000 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 2000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 3000);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 3000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- SignalData data;
- GestureReceivedFunctor functor(data);
+ SignalData data;
+ GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Add a layer to overlap the actor
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer );
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer);
layer.RaiseToTop();
// Render and notify
application.Render();
// Emit signals, should receive
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Set layer to consume all touch
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
// Render and notify
application.SendNotification();
application.Render();
// Emit the same signals again, should not receive
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 1500 );
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 2000);
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 1500);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 2000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
- bool consume = false;
+ bool consume = false;
TouchEventFunctorConsumeSetter touchFunctor(consume);
- actor.TouchedSignal().Connect(&application,touchFunctor);
+ actor.TouchedSignal().Connect(&application, touchFunctor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start gesture within the actor's area, we should receive the rotation as the touch is NOT being consumed
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
// Continue the gesture within the actor's area, but now the touch consumes thus cancelling the gesture
consume = true;
- TestContinueRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 15.0f, 20.0f ), Vector2( 25.0f, 20.0f ), 500 );
+ TestContinueRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(15.0f, 20.0f), Vector2(25.0f, 20.0f), 500);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(GestureState::CANCELLED, data.receivedGesture.GetState(), TEST_LOCATION);
data.Reset();
// Start another rotation, we should not even get the callback this time
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- RotationGestureDetector detector = RotationGestureDetector::New();
- bool functorCalled = false;
- detector.Attach( actor );
+ RotationGestureDetector detector = RotationGestureDetector::New();
+ bool functorCalled = false;
+ detector.Attach(actor);
detector.DetectedSignal().Connect(
- &application,
- [&detector, &functorCalled](Actor actor, const RotationGesture& gesture)
+ &application,
+ [&detector, &functorCalled](Actor actor, const RotationGesture& gesture) {
+ if(gesture.GetState() == GestureState::FINISHED)
{
- if( gesture.GetState() == GestureState::FINISHED )
- {
- detector.Detach(actor);
- functorCalled = true;
- }
- });
+ detector.Detach(actor);
+ functorCalled = true;
+ }
+ });
// Render and notify
application.SendNotification();
// Try the gesture, should not crash
try
{
- TestStartRotation( application, Vector2( 2.0f, 20.0f ), Vector2( 38.0f, 20.0f ),
- Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ), 100 );
- TestContinueRotation( application, Vector2( 112.0f, 100.0f ), Vector2( 112.0f, 124.0f ),
- Vector2( 5.0f, 5.0f ), Vector2( 35.0f, 35.0f ), 200 );
- TestEndRotation( application, Vector2( 10.0f, 20.0f ), Vector2( 30.0f, 20.0f ),
- Vector2( 19.0f, 20.0f ), Vector2( 21.0f, 20.0f ), 1000);
-
- DALI_TEST_CHECK( true ); // No crash, test has passed
+ TestStartRotation(application, Vector2(2.0f, 20.0f), Vector2(38.0f, 20.0f), Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), 100);
+ TestContinueRotation(application, Vector2(112.0f, 100.0f), Vector2(112.0f, 124.0f), Vector2(5.0f, 5.0f), Vector2(35.0f, 35.0f), 200);
+ TestEndRotation(application, Vector2(10.0f, 20.0f), Vector2(30.0f, 20.0f), Vector2(19.0f, 20.0f), Vector2(21.0f, 20.0f), 1000);
+
+ DALI_TEST_CHECK(true); // No crash, test has passed
DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
}
catch(...)
{
- DALI_TEST_CHECK( false ); // If we crash, the test has failed
+ DALI_TEST_CHECK(false); // If we crash, the test has failed
}
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/input-options.h>
-#include <dali/integration-api/events/touch-event-integ.h>
#include <dali-test-suite-utils.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/input-options.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
struct SignalData
{
SignalData()
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
rotatedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
RotationGesture receivedGesture;
- Actor rotatedActor;
+ Actor rotatedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const RotationGesture& rotation)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = rotation;
- signalData.rotatedActor = actor;
+ signalData.rotatedActor = actor;
}
void operator()()
SignalData& signalData;
};
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-Integration::TouchEvent GenerateDoubleTouch( PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time )
+Integration::TouchEvent GenerateDoubleTouch(PointState::Type stateA, const Vector2& screenPositionA, PointState::Type stateB, const Vector2& screenPositionB, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( stateA );
- point.SetScreenPosition( screenPositionA );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
- point.SetScreenPosition( screenPositionB );
- point.SetState( stateB);
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(stateA);
+ point.SetScreenPosition(screenPositionA);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
+ point.SetScreenPosition(screenPositionB);
+ point.SetState(stateB);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
int UtcDaliRotationGestureRecognizerRealistic(void)
RotationGestureDetector detector = RotationGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 100 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 105 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 110 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 25.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 115 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 30.0f ), PointState::MOTION, Vector2( 20.0f, 85.0f ), 120 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 35.0f ), PointState::MOTION, Vector2( 20.0f, 80.0f ), 125 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 40.0f ), PointState::MOTION, Vector2( 20.0f, 75.0f ), 130 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 45.0f ), PointState::MOTION, Vector2( 20.0f, 70.0f ), 135 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 50.0f ), PointState::MOTION, Vector2( 20.0f, 65.0f ), 140 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 55.0f ), PointState::MOTION, Vector2( 20.0f, 60.0f ), 145 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 56.0f ), 155 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 100));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 105));
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 110));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 25.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 115));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 30.0f), PointState::MOTION, Vector2(20.0f, 85.0f), 120));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 35.0f), PointState::MOTION, Vector2(20.0f, 80.0f), 125));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 40.0f), PointState::MOTION, Vector2(20.0f, 75.0f), 130));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 45.0f), PointState::MOTION, Vector2(20.0f, 70.0f), 135));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 50.0f), PointState::MOTION, Vector2(20.0f, 65.0f), 140));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 55.0f), PointState::MOTION, Vector2(20.0f, 60.0f), 145));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 56.0f), 155));
application.SendNotification();
RotationGestureDetector detector = RotationGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
// application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
// application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 20.0f, 25.0f ), 151 ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 20.0f, 30.0f ), 152 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(20.0f, 30.0f), 152));
application.SendNotification();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
- detector.Attach( actor );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ detector.DetectedSignal().Connect(&application, functor);
// Case 1
// 2 touch events make a gesture begin
- Integration::SetRotationGestureMinimumTouchEvents( 2 );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 90.0f, 90.0f ), 160 ) );
+ Integration::SetRotationGestureMinimumTouchEvents(2);
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(90.0f, 90.0f), 160));
- DALI_TEST_EQUALS( GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Case 2
// 4 touch events make a gesture begin
- Integration::SetRotationGestureMinimumTouchEvents( 4 );
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 90.0f, 90.0f ), 160 ) );
+ Integration::SetRotationGestureMinimumTouchEvents(4);
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(90.0f, 90.0f), 160));
// Check the gesture is not detected unlike previous case
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
RotationGestureDetector detector = RotationGestureDetector::New();
- detector.Attach( actor );
- detector.DetectedSignal().Connect( &application, functor );
+ detector.Attach(actor);
+ detector.DetectedSignal().Connect(&application, functor);
// Case 1
// > 2 touch events make a gesture begin
Integration::SetRotationGestureMinimumTouchEvents(2);
Integration::SetRotationGestureMinimumTouchEventsAfterStart(6);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), PointState::DOWN, Vector2( 20.0f, 90.0f ), 150 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 90.0f, 90.0f ), 160 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), PointState::DOWN, Vector2(20.0f, 90.0f), 150));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(90.0f, 90.0f), 160));
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 170 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 180 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 190 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 170));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 180));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 190));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 200));
// > Test : not enough touch events to make the gesture state "CONTINUING"
DALI_TEST_EQUALS(GestureState::STARTED, data.receivedGesture.GetState(), TEST_LOCATION);
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 210 ) );
- application.ProcessEvent( GenerateDoubleTouch( PointState::MOTION, Vector2( 20.0f, 20.0f ), PointState::MOTION, Vector2( 20.0f, 90.0f ), 220 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 210));
+ application.ProcessEvent(GenerateDoubleTouch(PointState::MOTION, Vector2(20.0f, 20.0f), PointState::MOTION, Vector2(20.0f, 90.0f), 220));
// > Test : 6 touch events after start make the gesture state "CONTINUING"
DALI_TEST_EQUALS(GestureState::CONTINUING, data.receivedGesture.GetState(), TEST_LOCATION);
// EXTERNAL INCLUDES
#include <dali/public-api/dali-core.h>
-#include <unistd.h>
#include <string.h>
+#include <unistd.h>
// INTERNAL INCLUDES
#include <dali-test-suite-utils.h>
int UtcDaliSamplerNew01(void)
{
TestApplication application;
- Sampler sampler = Sampler::New();
+ Sampler sampler = Sampler::New();
- DALI_TEST_EQUALS( (bool)sampler, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)sampler, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliSamplerNew02(void)
{
TestApplication application;
- Sampler sampler;
- DALI_TEST_EQUALS( (bool)sampler, false, TEST_LOCATION );
+ Sampler sampler;
+ DALI_TEST_EQUALS((bool)sampler, false, TEST_LOCATION);
END_TEST;
}
// Copy the object, ref count == 2
Sampler copy(sampler);
DALI_TEST_CHECK(copy);
- if (copy)
+ if(copy)
{
DALI_TEST_EQUALS(2, copy.GetBaseObject().ReferenceCount(), TEST_LOCATION);
}
TestApplication application;
Sampler sampler = Sampler::New();
- DALI_TEST_CHECK( sampler );
- DALI_TEST_EQUALS( 1, sampler.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(sampler);
+ DALI_TEST_EQUALS(1, sampler.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- Sampler move = std::move( sampler );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !sampler );
+ Sampler move = std::move(sampler);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!sampler);
END_TEST;
}
TestApplication application;
Sampler sampler = Sampler::New();
- DALI_TEST_CHECK( sampler );
- DALI_TEST_EQUALS( 1, sampler.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(sampler);
+ DALI_TEST_EQUALS(1, sampler.GetBaseObject().ReferenceCount(), TEST_LOCATION);
Sampler move;
- move = std::move( sampler );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( !sampler );
+ move = std::move(sampler);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(!sampler);
END_TEST;
}
int UtcDaliSamplerDownCast01(void)
{
TestApplication application;
- Sampler sampler = Sampler::New();
+ Sampler sampler = Sampler::New();
BaseHandle handle(sampler);
- Sampler sampler2 = Sampler::DownCast(handle);
- DALI_TEST_EQUALS( (bool)sampler2, true, TEST_LOCATION );
+ Sampler sampler2 = Sampler::DownCast(handle);
+ DALI_TEST_EQUALS((bool)sampler2, true, TEST_LOCATION);
END_TEST;
}
TestApplication application;
BaseHandle handle;
- Sampler sampler = Sampler::DownCast(handle);
- DALI_TEST_EQUALS( (bool)sampler, false, TEST_LOCATION );
+ Sampler sampler = Sampler::DownCast(handle);
+ DALI_TEST_EQUALS((bool)sampler, false, TEST_LOCATION);
END_TEST;
}
int UtcDaliSamplerAssignmentOperator(void)
{
TestApplication application;
- Sampler sampler1 = Sampler::New();
+ Sampler sampler1 = Sampler::New();
Sampler sampler2;
{
TestApplication application;
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
Sampler sampler = Sampler::New();
TextureSet textureSet = CreateTextureSet();
textureSet.SetTexture(0u, image);
- textureSet.SetSampler( 0u, sampler );
+ textureSet.SetSampler(0u, sampler);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- application.GetScene().Add( actor );
-
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
// Default/Default
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
- sampler.SetFilterMode( FilterMode::DEFAULT, FilterMode::DEFAULT );
+ sampler.SetFilterMode(FilterMode::DEFAULT, FilterMode::DEFAULT);
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// There are 4 calls to TexParameteri when the texture is first created
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 4, TEST_LOCATION);
std::stringstream out;
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_LINEAR;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
/**************************************************************/
// Linear/Linear
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
- sampler.SetFilterMode( FilterMode::LINEAR, FilterMode::LINEAR );
+ sampler.SetFilterMode(FilterMode::LINEAR, FilterMode::LINEAR);
// Flush the queue and render once
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// Should not make any calls when settings are the same (DEFAULT = LINEAR )
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 0, TEST_LOCATION);
/**************************************************************/
// Nearest/Nearest
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
// Flush the queue and render once
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify actor gl state
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 2, TEST_LOCATION);
out.str("");
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
out.str("");
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_NEAREST;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(1, "TexParameteri", out.str()), true, TEST_LOCATION);
/**************************************************************/
// Nearest/Linear
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::LINEAR );
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::LINEAR);
// Flush the queue and render once
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify actor gl state
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 1, TEST_LOCATION);
out.str("");
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MAG_FILTER << ", " << GL_LINEAR;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
/**************************************************************/
// NONE/NONE
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
- sampler.SetFilterMode( FilterMode::NONE, FilterMode::NONE );
+ sampler.SetFilterMode(FilterMode::NONE, FilterMode::NONE);
// Flush the queue and render once
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify actor gl state
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 1, TEST_LOCATION);
out.str("");
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_MIN_FILTER << ", " << GL_NEAREST_MIPMAP_LINEAR;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(0, "TexParameteri", out.str()), true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
TextureSet textureSet = CreateTextureSet();
- Sampler sampler = Sampler::New();
+ Sampler sampler = Sampler::New();
textureSet.SetTexture(0u, image);
- textureSet.SetSampler( 0u, sampler );
+ textureSet.SetSampler(0u, sampler);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
// CLAMP_TO_EDGE / CLAMP_TO_EDGE
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// There are 4 calls to TexParameteri when the texture is first created
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 4, TEST_LOCATION);
std::stringstream out;
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_S << ", " << GL_CLAMP_TO_EDGE;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(2, "TexParameteri", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(2, "TexParameteri", out.str()), true, TEST_LOCATION);
out.str("");
out << GL_TEXTURE_2D << ", " << GL_TEXTURE_WRAP_T << ", " << GL_CLAMP_TO_EDGE;
- DALI_TEST_EQUALS( texParameterTrace.TestMethodAndParams(3, "TexParameteri", out.str()), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.TestMethodAndParams(3, "TexParameteri", out.str()), true, TEST_LOCATION);
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
- sampler.SetWrapMode( WrapMode::DEFAULT, WrapMode::DEFAULT );
+ sampler.SetWrapMode(WrapMode::DEFAULT, WrapMode::DEFAULT);
// Flush the queue and render once
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// Should not make any calls when settings are the same
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 0, TEST_LOCATION);
//Todo: Test the other wrap mode ( REPEAT, MIRRORED_REPEAT ) , currently not support!!
TestApplication application;
// Create a cube-map texture.
- unsigned int width = 8u;
- unsigned int height = 8u;
- Texture texture = Texture::New( TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height );
+ unsigned int width = 8u;
+ unsigned int height = 8u;
+ Texture texture = Texture::New(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
// Create source image data.
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= new unsigned char[ bufferSize ];
- memset( buffer, 0u, bufferSize );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = new unsigned char[bufferSize];
+ memset(buffer, 0u, bufferSize);
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::DELETE_ARRAY );
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::DELETE_ARRAY);
// Upload the source image data to all 6 sides of our cube-map.
- texture.Upload( pixelData, CubeMapLayer::POSITIVE_X, 0u, 0u, 0u, width, height );
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height );
- texture.Upload( pixelData, CubeMapLayer::POSITIVE_Y, 0u, 0u, 0u, width, height );
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_Y, 0u, 0u, 0u, width, height );
- texture.Upload( pixelData, CubeMapLayer::POSITIVE_Z, 0u, 0u, 0u, width, height );
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_Z, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::POSITIVE_X, 0u, 0u, 0u, width, height);
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height);
+ texture.Upload(pixelData, CubeMapLayer::POSITIVE_Y, 0u, 0u, 0u, width, height);
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_Y, 0u, 0u, 0u, width, height);
+ texture.Upload(pixelData, CubeMapLayer::POSITIVE_Z, 0u, 0u, 0u, width, height);
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_Z, 0u, 0u, 0u, width, height);
// Finalize the cube-map setup.
TextureSet textureSet = TextureSet::New();
- textureSet.SetTexture( 0u, texture );
+ textureSet.SetTexture(0u, texture);
Sampler sampler = Sampler::New();
- textureSet.SetSampler( 0u, sampler );
+ textureSet.SetSampler(0u, sampler);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+ application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
// Call the 3 dimensional wrap mode API.
- sampler.SetWrapMode( WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE );
+ sampler.SetWrapMode(WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE, WrapMode::CLAMP_TO_EDGE);
application.SendNotification();
application.Render();
// Verify that no TexParameteri calls occurred since wrap mode hasn't changed.
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 0u, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 0u, TEST_LOCATION);
- sampler.SetWrapMode( WrapMode::REPEAT, WrapMode::REPEAT, WrapMode::REPEAT );
+ sampler.SetWrapMode(WrapMode::REPEAT, WrapMode::REPEAT, WrapMode::REPEAT);
texParameterTrace.Reset();
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify that 3 TexParameteri calls occurred.
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 3u, TEST_LOCATION );
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 3u, TEST_LOCATION);
END_TEST;
}
int UtcDaliSamplerSetWrapModeNegative01(void)
{
TestApplication application;
- Dali::Sampler instance;
+ Dali::Sampler instance;
try
{
Dali::WrapMode::Type arg1(static_cast<Dali::WrapMode::Type>(-1));
Dali::WrapMode::Type arg2(static_cast<Dali::WrapMode::Type>(-1));
- instance.SetWrapMode(arg1,arg2);
+ instance.SetWrapMode(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliSamplerSetWrapModeNegative02(void)
{
TestApplication application;
- Dali::Sampler instance;
+ Dali::Sampler instance;
try
{
Dali::WrapMode::Type arg1(static_cast<Dali::WrapMode::Type>(-1));
Dali::WrapMode::Type arg2(static_cast<Dali::WrapMode::Type>(-1));
Dali::WrapMode::Type arg3(static_cast<Dali::WrapMode::Type>(-1));
- instance.SetWrapMode(arg1,arg2,arg3);
+ instance.SetWrapMode(arg1, arg2, arg3);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliSamplerSetFilterModeNegative(void)
{
TestApplication application;
- Dali::Sampler instance;
+ Dali::Sampler instance;
try
{
Dali::FilterMode::Type arg1(static_cast<Dali::FilterMode::Type>(-1));
Dali::FilterMode::Type arg2(static_cast<Dali::FilterMode::Type>(-1));
- instance.SetFilterMode(arg1,arg2);
+ instance.SetFilterMode(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/integration-api/scene.h>
-#include <dali/integration-api/events/key-event-integ.h>
-#include <dali/public-api/events/key-event.h>
+#include <dali-test-suite-utils.h>
#include <dali/devel-api/common/stage.h>
+#include <dali/integration-api/events/key-event-integ.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
-
-#include <dali-test-suite-utils.h>
+#include <dali/integration-api/scene.h>
+#include <dali/public-api/events/key-event.h>
#include <mesh-builder.h>
+#include <stdlib.h>
+
+#include <iostream>
// Internal headers are allowed here
namespace
{
-
const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
// Functor for EventProcessingFinished signal
/**
* @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
*/
- EventProcessingFinishedFunctor( bool& eventProcessingFinished )
- : mEventProcessingFinished( eventProcessingFinished )
- {}
+ EventProcessingFinishedFunctor(bool& eventProcessingFinished)
+ : mEventProcessingFinished(eventProcessingFinished)
+ {
+ }
void operator()()
{
{
KeyEventSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
receivedKeyEvent.Reset();
}
- bool functorCalled;
+ bool functorCalled;
KeyEvent receivedKeyEvent;
};
// Functor that sets the data when called
struct KeyEventReceivedFunctor
{
- KeyEventReceivedFunctor( KeyEventSignalData& data ) : signalData( data ) { }
+ KeyEventReceivedFunctor(KeyEventSignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( const KeyEvent& keyEvent )
+ bool operator()(const KeyEvent& keyEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedKeyEvent = keyEvent;
return true;
: functorCalled(false),
createNewScene(false),
newSceneCreated(false)
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
- createNewScene = false;
+ functorCalled = false;
+ createNewScene = false;
newSceneCreated = false;
receivedTouchEvent.Reset();
}
- bool functorCalled;
- bool createNewScene;
- bool newSceneCreated;
+ bool functorCalled;
+ bool createNewScene;
+ bool newSceneCreated;
TouchEvent receivedTouchEvent;
};
// Functor that sets the data when touched signal is received
struct TouchFunctor
{
- TouchFunctor( TouchedSignalData& data ) : signalData( data ) { }
+ TouchFunctor(TouchedSignalData& data)
+ : signalData(data)
+ {
+ }
- void operator()( const TouchEvent& touch )
+ void operator()(const TouchEvent& touch)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedTouchEvent = touch;
- if ( signalData.createNewScene )
+ if(signalData.createNewScene)
{
- Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
- DALI_TEST_CHECK( scene );
+ Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
+ DALI_TEST_CHECK(scene);
signalData.newSceneCreated = true;
}
{
WheelEventSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
functorCalled = false;
}
- bool functorCalled;
+ bool functorCalled;
WheelEvent receivedWheelEvent;
};
// Functor that sets the data when wheel-event signal is received
struct WheelEventReceivedFunctor
{
- WheelEventReceivedFunctor( WheelEventSignalData& data ) : signalData( data ) { }
+ WheelEventReceivedFunctor(WheelEventSignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( const WheelEvent& wheelEvent )
+ bool operator()(const WheelEvent& wheelEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedWheelEvent = wheelEvent;
return true;
{
KeyEventGeneratedSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
receivedKeyEvent.Reset();
}
- bool functorCalled;
+ bool functorCalled;
KeyEvent receivedKeyEvent;
};
// Functor that sets the data when called
struct KeyEventGeneratedReceivedFunctor
{
- KeyEventGeneratedReceivedFunctor( KeyEventGeneratedSignalData& data )
- : signalData( data )
- {}
+ KeyEventGeneratedReceivedFunctor(KeyEventGeneratedSignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( const KeyEvent& keyEvent )
+ bool operator()(const KeyEvent& keyEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedKeyEvent = keyEvent;
return true;
KeyEventGeneratedSignalData& signalData;
};
-void GenerateTouch( TestApplication& application, PointState::Type state, const Vector2& screenPosition )
+void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- touchEvent.points.push_back( point );
- application.ProcessEvent( touchEvent );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ touchEvent.points.push_back(point);
+ application.ProcessEvent(touchEvent);
}
-bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
+bool DummyTouchCallback(Actor actor, const TouchEvent& touch)
{
return true;
}
-void FrameCallback( int frameId )
+void FrameCallback(int frameId)
{
}
Dali::Integration::Scene scene = application.GetScene();
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
- scene.Add( actor );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ scene.Add(actor);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
END_TEST;
}
Dali::Integration::Scene scene = application.GetScene();
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
- scene.Add( actor );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ scene.Add(actor);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
scene.Remove(actor);
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
END_TEST;
}
tet_infoline("Testing Dali::Integration::Scene::GetSize");
Dali::Integration::Scene scene = application.GetScene();
- Size size = scene.GetSize();
- DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION );
- DALI_TEST_EQUALS( TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION );
+ Size size = scene.GetSize();
+ DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_WIDTH, size.width, TEST_LOCATION);
+ DALI_TEST_EQUALS(TestApplication::DEFAULT_SURFACE_HEIGHT, size.height, TEST_LOCATION);
END_TEST;
}
// Test that setting core DPI explicitly also sets up the scene's DPI.
Dali::Integration::Scene scene = application.GetScene();
- scene.SetDpi( Vector2(200.0f, 180.0f) );
+ scene.SetDpi(Vector2(200.0f, 180.0f));
Vector2 dpi = scene.GetDpi();
- DALI_TEST_EQUALS( dpi.x, 200.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( dpi.y, 180.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
END_TEST;
}
const RenderTaskList& tasks = scene.GetRenderTaskList();
// There should be 1 task by default.
- DALI_TEST_EQUALS( tasks.GetTaskCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
// RenderTaskList has it's own UTC tests.
// But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
RenderTask newTask = scene.GetRenderTaskList().CreateTask();
- DALI_TEST_EQUALS( scene.GetRenderTaskList().GetTask( 1 ), newTask, TEST_LOCATION );
+ DALI_TEST_EQUALS(scene.GetRenderTaskList().GetTask(1), newTask, TEST_LOCATION);
END_TEST;
}
tet_infoline("Testing Dali::Integration::Scene::GetRootLayer");
Dali::Integration::Scene scene = application.GetScene();
- Layer layer = scene.GetLayer( 0 );
- DALI_TEST_CHECK( layer );
+ Layer layer = scene.GetLayer(0);
+ DALI_TEST_CHECK(layer);
// Check that GetRootLayer() correctly retreived layer 0.
- DALI_TEST_CHECK( scene.GetRootLayer() == layer );
+ DALI_TEST_CHECK(scene.GetRootLayer() == layer);
END_TEST;
}
Dali::Integration::Scene scene = application.GetScene();
// Initially we have a default layer
- DALI_TEST_EQUALS( scene.GetLayerCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(scene.GetLayerCount(), 1u, TEST_LOCATION);
Layer layer = Layer::New();
- scene.Add( layer );
+ scene.Add(layer);
- DALI_TEST_EQUALS( scene.GetLayerCount(), 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(scene.GetLayerCount(), 2u, TEST_LOCATION);
END_TEST;
}
Dali::Integration::Scene scene = application.GetScene();
- Layer rootLayer = scene.GetLayer( 0 );
- DALI_TEST_CHECK( rootLayer );
+ Layer rootLayer = scene.GetLayer(0);
+ DALI_TEST_CHECK(rootLayer);
Layer layer = Layer::New();
- scene.Add( layer );
+ scene.Add(layer);
- Layer sameLayer = scene.GetLayer( 1 );
- DALI_TEST_CHECK( layer == sameLayer );
+ Layer sameLayer = scene.GetLayer(1);
+ DALI_TEST_CHECK(layer == sameLayer);
END_TEST;
}
Dali::Integration::Scene scene = application.GetScene();
Actor actor = Actor::New();
- DALI_TEST_CHECK( Dali::Integration::Scene() == Dali::Integration::Scene::Get( actor ) );
+ DALI_TEST_CHECK(Dali::Integration::Scene() == Dali::Integration::Scene::Get(actor));
- scene.Add( actor );
+ scene.Add(actor);
- DALI_TEST_CHECK( scene == Dali::Integration::Scene::Get( actor ) );
+ DALI_TEST_CHECK(scene == Dali::Integration::Scene::Get(actor));
END_TEST;
}
tet_infoline("Testing Dali::Scene::Discard");
// Create a new Scene
- Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
- DALI_TEST_CHECK( scene );
+ Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
+ DALI_TEST_CHECK(scene);
// One reference of scene kept here and the other one kept in the Core
- DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 2 );
+ DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
// Render and notify.
application.SendNotification();
// Keep the reference of the root layer handle so it will still be alive after the scene is deleted
Layer rootLayer = scene.GetRootLayer();
- DALI_TEST_CHECK( rootLayer );
- DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 2 );
+ DALI_TEST_CHECK(rootLayer);
+ DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
// Request to discard the scene from the Core
scene.Discard();
- DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 1 );
+ DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
// Reset the scene handle
scene.Reset();
// At this point, the scene should have been automatically deleted
// To prove this, the ref count of the root layer handle should be decremented to 1
- DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 );
+ DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
// Delete the root layer handle
rootLayer.Reset();
TouchedSignalData data;
data.createNewScene = true;
- TouchFunctor functor( data );
- scene.TouchedSignal().Connect( &application, functor );
+ TouchFunctor functor(data);
+ scene.TouchedSignal().Connect(&application, functor);
// Render and notify.
application.SendNotification();
application.Render();
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, data.createNewScene, TEST_LOCATION );
- DALI_TEST_EQUALS( true, data.newSceneCreated, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, data.createNewScene, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, data.newSceneCreated, TEST_LOCATION);
data.Reset();
END_TEST;
TestApplication application;
// Create a Scene
- Dali::Integration::Scene scene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
- DALI_TEST_CHECK( scene );
+ Dali::Integration::Scene scene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
+ DALI_TEST_CHECK(scene);
// One reference of scene kept here and the other one kept in the Core
- DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 2 );
+ DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 2);
// Add a renderable actor to the scene
auto actor = CreateRenderableActor();
- scene.Add( actor );
+ scene.Add(actor);
// Render and notify.
application.SendNotification();
// Keep the reference of the root layer handle so it will still be alive after the scene is deleted
Layer rootLayer = scene.GetRootLayer();
- DALI_TEST_CHECK( rootLayer );
- DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 2 );
+ DALI_TEST_CHECK(rootLayer);
+ DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 2);
// Request to discard the scene from the Core
scene.Discard();
- DALI_TEST_CHECK( scene.GetBaseObject().ReferenceCount() == 1 );
+ DALI_TEST_CHECK(scene.GetBaseObject().ReferenceCount() == 1);
// Reset the scene handle
scene.Reset();
// At this point, the scene should have been automatically deleted
// To prove this, the ref count of the root layer handle should be decremented to 1
- DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 );
+ DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
// Create a new Scene while the root layer of the deleted scene is still alive
- Dali::Integration::Scene newScene = Dali::Integration::Scene::New( Size( 480.0f, 800.0f ) );
- DALI_TEST_CHECK( newScene );
+ Dali::Integration::Scene newScene = Dali::Integration::Scene::New(Size(480.0f, 800.0f));
+ DALI_TEST_CHECK(newScene);
// Render and notify.
application.SendNotification();
// At this point, we have only one scene but two root layers
// The root layer of the deleted scene is still alive
- DALI_TEST_CHECK( rootLayer.GetBaseObject().ReferenceCount() == 1 );
+ DALI_TEST_CHECK(rootLayer.GetBaseObject().ReferenceCount() == 1);
// Delete the root layer of the deleted scene
rootLayer.Reset();
int UtcDaliSceneEventProcessingFinishedP(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
- bool eventProcessingFinished = false;
- EventProcessingFinishedFunctor functor( eventProcessingFinished );
- scene.EventProcessingFinishedSignal().Connect( &application, functor );
+ bool eventProcessingFinished = false;
+ EventProcessingFinishedFunctor functor(eventProcessingFinished);
+ scene.EventProcessingFinishedSignal().Connect(&application, functor);
- Actor actor( Actor::New() );
- scene.Add( actor );
+ Actor actor(Actor::New());
+ scene.Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( eventProcessingFinished );
+ DALI_TEST_CHECK(eventProcessingFinished);
END_TEST;
}
int UtcDaliSceneEventProcessingFinishedN(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
- bool eventProcessingFinished = false;
- EventProcessingFinishedFunctor functor( eventProcessingFinished );
- scene.EventProcessingFinishedSignal().Connect( &application, functor );
+ bool eventProcessingFinished = false;
+ EventProcessingFinishedFunctor functor(eventProcessingFinished);
+ scene.EventProcessingFinishedSignal().Connect(&application, functor);
- Actor actor( Actor::New() );
- scene.Add( actor );
+ Actor actor(Actor::New());
+ scene.Add(actor);
// Do not complete event processing and confirm the signal has not been emitted.
- DALI_TEST_CHECK( !eventProcessingFinished );
+ DALI_TEST_CHECK(!eventProcessingFinished);
END_TEST;
}
int UtcDaliSceneSignalKeyEventP(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
- KeyEventSignalData data;
- KeyEventReceivedFunctor functor( data );
- scene.KeyEventSignal().Connect( &application, functor );
+ KeyEventSignalData data;
+ KeyEventReceivedFunctor functor(data);
+ scene.KeyEventSignal().Connect(&application, functor);
- Integration::KeyEvent event( "i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event );
+ Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event2( "i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event2 );
+ Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event2);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event3( "a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event3 );
+ Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event3);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event4( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event4 );
+ Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event4);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
END_TEST;
}
int UtcDaliSceneSignalKeyEventN(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
- KeyEventSignalData data;
- KeyEventReceivedFunctor functor( data );
- scene.KeyEventSignal().Connect( &application, functor );
+ KeyEventSignalData data;
+ KeyEventReceivedFunctor functor(data);
+ scene.KeyEventSignal().Connect(&application, functor);
// Check that a non-pressed key events data is not modified.
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
int UtcDaliSceneTouchedSignalP(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
TouchedSignalData data;
- TouchFunctor functor( data );
- scene.TouchedSignal().Connect( &application, functor );
+ TouchFunctor functor(data);
+ scene.TouchedSignal().Connect(&application, functor);
// Render and notify.
application.SendNotification();
// Basic test: No actors, single touch (down then up).
{
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
- GenerateTouch( application, PointState::UP, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::UP, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
// Add an actor to the scene.
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.TouchedSignal().Connect( &DummyTouchCallback );
- scene.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.TouchedSignal().Connect(&DummyTouchCallback);
+ scene.Add(actor);
// Render and notify.
application.SendNotification();
// Actor on scene, single touch, down in actor, motion, then up outside actor.
{
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) == actor );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
data.Reset();
- GenerateTouch( application, PointState::MOTION, Vector2( 150.0f, 10.0f ) ); // Some motion
+ GenerateTouch(application, PointState::MOTION, Vector2(150.0f, 10.0f)); // Some motion
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- GenerateTouch( application, PointState::UP, Vector2( 150.0f, 10.0f ) ); // Some motion
+ GenerateTouch(application, PointState::UP, Vector2(150.0f, 10.0f)); // Some motion
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
// Multiple touch. Should only receive a touch on first down and last up.
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
+ Integration::Point point;
// 1st point
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
- touchEvent.points.push_back( point );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.0f, 10.0f));
+ touchEvent.points.push_back(point);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
data.Reset();
// 2nd point
- touchEvent.points[0].SetState( PointState::STATIONARY );
- point.SetDeviceId( 1 );
- point.SetScreenPosition( Vector2( 50.0f, 50.0f ) );
- touchEvent.points.push_back( point );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ touchEvent.points[0].SetState(PointState::STATIONARY);
+ point.SetDeviceId(1);
+ point.SetScreenPosition(Vector2(50.0f, 50.0f));
+ touchEvent.points.push_back(point);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Primary point is up
- touchEvent.points[0].SetState( PointState::UP );
- touchEvent.points[1].SetState( PointState::STATIONARY );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ touchEvent.points[0].SetState(PointState::UP);
+ touchEvent.points[1].SetState(PointState::STATIONARY);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Remove 1st point now, 2nd point is now in motion
- touchEvent.points.erase( touchEvent.points.begin() );
- touchEvent.points[0].SetState( PointState::MOTION );
- touchEvent.points[0].SetScreenPosition( Vector2( 150.0f, 50.0f ) );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ touchEvent.points.erase(touchEvent.points.begin());
+ touchEvent.points[0].SetState(PointState::MOTION);
+ touchEvent.points[0].SetScreenPosition(Vector2(150.0f, 50.0f));
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Final point Up
- touchEvent.points[0].SetState( PointState::UP );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+ touchEvent.points[0].SetState(PointState::UP);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
data.Reset();
}
END_TEST;
int UtcDaliSceneTouchedSignalN(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
TouchedSignalData data;
- TouchFunctor functor( data );
- scene.TouchedSignal().Connect( &application, functor );
+ TouchFunctor functor(data);
+ scene.TouchedSignal().Connect(&application, functor);
// Render and notify.
application.SendNotification();
application.Render();
// Confirm functor not called before there has been any touch event.
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// No actors, single touch, down, motion then up.
{
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
// Confirm there is no signal when the touchpoint is only moved.
- GenerateTouch( application, PointState::MOTION, Vector2( 1200.0f, 10.0f ) ); // Some motion
+ GenerateTouch(application, PointState::MOTION, Vector2(1200.0f, 10.0f)); // Some motion
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Confirm a following up event generates a signal.
- GenerateTouch( application, PointState::UP, Vector2( 1200.0f, 10.0f ) );
+ GenerateTouch(application, PointState::UP, Vector2(1200.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
// Add an actor to the scene.
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.TouchedSignal().Connect( &DummyTouchCallback );
- scene.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.TouchedSignal().Connect(&DummyTouchCallback);
+ scene.Add(actor);
// Render and notify.
application.SendNotification();
// Actor on scene. Interrupted before down and interrupted after down.
{
- GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
data.Reset();
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) == actor );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::DOWN );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::DOWN);
data.Reset();
- GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
// Check that getting info about a non-existent point returns an empty handle
- Actor actor = data.receivedTouchEvent.GetHitActor( 1 );
- DALI_TEST_CHECK( !actor );
+ Actor actor = data.receivedTouchEvent.GetHitActor(1);
+ DALI_TEST_CHECK(!actor);
data.Reset();
}
int UtcDaliSceneSignalWheelEventP(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
- WheelEventSignalData data;
- WheelEventReceivedFunctor functor( data );
- scene.WheelEventSignal().Connect( &application, functor );
+ WheelEventSignalData data;
+ WheelEventReceivedFunctor functor(data);
+ scene.WheelEventSignal().Connect(&application, functor);
- Integration::WheelEvent event( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), 1, 1000u );
- application.ProcessEvent( event );
+ Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
+ application.ProcessEvent(event);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event.type) == data.receivedWheelEvent.GetType() );
- DALI_TEST_CHECK( event.direction == data.receivedWheelEvent.GetDirection() );
- DALI_TEST_CHECK( event.modifiers == data.receivedWheelEvent.GetModifiers() );
- DALI_TEST_CHECK( event.point == data.receivedWheelEvent.GetPoint() );
- DALI_TEST_CHECK( event.delta == data.receivedWheelEvent.GetDelta() );
- DALI_TEST_CHECK( event.timeStamp == data.receivedWheelEvent.GetTime() );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
+ DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
+ DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
+ DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
+ DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
+ DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
data.Reset();
- Integration::WheelEvent event2( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), -1, 1000u );
- application.ProcessEvent( event2 );
+ Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
+ application.ProcessEvent(event2);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event2.type) == data.receivedWheelEvent.GetType() );
- DALI_TEST_CHECK( event2.direction == data.receivedWheelEvent.GetDirection() );
- DALI_TEST_CHECK( event2.modifiers == data.receivedWheelEvent.GetModifiers() );
- DALI_TEST_CHECK( event2.point == data.receivedWheelEvent.GetPoint() );
- DALI_TEST_CHECK( event2.delta == data.receivedWheelEvent.GetDelta() );
- DALI_TEST_CHECK( event2.timeStamp == data.receivedWheelEvent.GetTime() );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
+ DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
+ DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
+ DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
+ DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
+ DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
END_TEST;
}
int UtcDaliSceneSurfaceResizedDefaultScene(void)
{
- tet_infoline( "Ensure resizing of the surface is handled properly" );
+ tet_infoline("Ensure resizing of the surface is handled properly");
TestApplication application;
auto defaultScene = application.GetScene();
- DALI_TEST_CHECK( defaultScene );
+ DALI_TEST_CHECK(defaultScene);
// Ensure stage size matches the scene size
auto stage = Stage::GetCurrent();
- DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
// Resize the scene
- Vector2 newSize( 1000.0f, 2000.0f );
- DALI_TEST_CHECK( stage.GetSize() != newSize );
- defaultScene.SurfaceResized( newSize.width, newSize.height );
+ Vector2 newSize(1000.0f, 2000.0f);
+ DALI_TEST_CHECK(stage.GetSize() != newSize);
+ defaultScene.SurfaceResized(newSize.width, newSize.height);
- DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION );
- DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
END_TEST;
}
int UtcDaliSceneSurfaceResizedDefaultSceneViewport(void)
{
- tet_infoline( "Ensure resizing of the surface & viewport is handled properly" );
+ tet_infoline("Ensure resizing of the surface & viewport is handled properly");
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& callStack = glAbstraction.GetViewportTrace();
- glAbstraction.EnableViewportCallTrace( true );
+ TraceCallStack& callStack = glAbstraction.GetViewportTrace();
+ glAbstraction.EnableViewportCallTrace(true);
// Initial scene setup
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
// Render before resizing surface
glAbstraction.ResetViewportCallStack();
auto defaultScene = application.GetScene();
- DALI_TEST_CHECK( defaultScene );
+ DALI_TEST_CHECK(defaultScene);
// Ensure stage size matches the scene size
auto stage = Stage::GetCurrent();
- DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
// Resize the scene
- Vector2 newSize( 1000.0f, 2000.0f );
- std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize
- DALI_TEST_CHECK( stage.GetSize() != newSize );
- defaultScene.SurfaceResized( newSize.width, newSize.height );
+ Vector2 newSize(1000.0f, 2000.0f);
+ std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
+ DALI_TEST_CHECK(stage.GetSize() != newSize);
+ defaultScene.SurfaceResized(newSize.width, newSize.height);
- DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION );
- DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
// Render after resizing surface
application.SendNotification();
application.Render(0);
// Check that the viewport is handled properly
- DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("Viewport", viewportParams ) );
+ DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
END_TEST;
}
int UtcDaliSceneSurfaceResizedMultipleRenderTasks(void)
{
- tet_infoline( "Ensure resizing of the surface & viewport is handled properly" );
+ tet_infoline("Ensure resizing of the surface & viewport is handled properly");
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
- TraceCallStack& callStack = glAbstraction.GetViewportTrace();
- glAbstraction.EnableViewportCallTrace( true );
+ TraceCallStack& callStack = glAbstraction.GetViewportTrace();
+ glAbstraction.EnableViewportCallTrace(true);
// Initial scene setup
auto scene = application.GetScene();
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- int testWidth = 400;
+ int testWidth = 400;
int testHeight = 400;
- actor.SetProperty( Actor::Property::SIZE, Vector2( testWidth, testHeight) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(testWidth, testHeight));
scene.Add(actor);
- CameraActor offscreenCameraActor = CameraActor::New( Size( testWidth, testHeight ) );
- application.GetScene().Add( offscreenCameraActor );
+ CameraActor offscreenCameraActor = CameraActor::New(Size(testWidth, testHeight));
+ application.GetScene().Add(offscreenCameraActor);
- FrameBuffer newFrameBuffer = FrameBuffer::New( testWidth, testHeight, FrameBuffer::Attachment::NONE );
+ FrameBuffer newFrameBuffer = FrameBuffer::New(testWidth, testHeight, FrameBuffer::Attachment::NONE);
RenderTask newTask = scene.GetRenderTaskList().CreateTask();
- newTask.SetCameraActor( offscreenCameraActor );
- newTask.SetSourceActor( actor );
- newTask.SetFrameBuffer( newFrameBuffer );
- newTask.SetViewportPosition( Vector2(0, 0) );
- newTask.SetViewportSize( Vector2(testWidth, testHeight) );
+ newTask.SetCameraActor(offscreenCameraActor);
+ newTask.SetSourceActor(actor);
+ newTask.SetFrameBuffer(newFrameBuffer);
+ newTask.SetViewportPosition(Vector2(0, 0));
+ newTask.SetViewportSize(Vector2(testWidth, testHeight));
// Render before resizing surface
application.SendNotification();
glAbstraction.ResetViewportCallStack();
Rect<int32_t> initialViewport = newTask.GetViewport();
- int initialWidth = initialViewport.width;
- int initialHeight = initialViewport.height;
- DALI_TEST_EQUALS( initialWidth, testWidth, TEST_LOCATION );
- DALI_TEST_EQUALS( initialHeight, testHeight, TEST_LOCATION );
+ int initialWidth = initialViewport.width;
+ int initialHeight = initialViewport.height;
+ DALI_TEST_EQUALS(initialWidth, testWidth, TEST_LOCATION);
+ DALI_TEST_EQUALS(initialHeight, testHeight, TEST_LOCATION);
auto defaultScene = application.GetScene();
- DALI_TEST_CHECK( defaultScene );
+ DALI_TEST_CHECK(defaultScene);
// Ensure stage size matches the scene size
auto stage = Stage::GetCurrent();
- DALI_TEST_EQUALS( stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), defaultScene.GetSize(), TEST_LOCATION);
// Resize the scene
- Vector2 newSize( 1000.0f, 2000.0f );
- std::string viewportParams( "0, 0, 1000, 2000" ); // to match newSize
- DALI_TEST_CHECK( stage.GetSize() != newSize );
- defaultScene.SurfaceResized( newSize.width, newSize.height );
+ Vector2 newSize(1000.0f, 2000.0f);
+ std::string viewportParams("0, 0, 1000, 2000"); // to match newSize
+ DALI_TEST_CHECK(stage.GetSize() != newSize);
+ defaultScene.SurfaceResized(newSize.width, newSize.height);
- DALI_TEST_EQUALS( stage.GetSize(), newSize, TEST_LOCATION );
- DALI_TEST_EQUALS( defaultScene.GetSize(), newSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), newSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(defaultScene.GetSize(), newSize, TEST_LOCATION);
// Render after resizing surface
application.SendNotification();
application.Render(0);
// Check that the viewport is handled properly
- DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("Viewport", viewportParams ) );
+ DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("Viewport", viewportParams));
// Second render-task should not be affected
Rect<int32_t> viewport = newTask.GetViewport();
- int width = viewport.width;
- int height = viewport.height;
- DALI_TEST_EQUALS( width, testWidth, TEST_LOCATION );
- DALI_TEST_EQUALS( height, testHeight, TEST_LOCATION );
+ int width = viewport.width;
+ int height = viewport.height;
+ DALI_TEST_EQUALS(width, testWidth, TEST_LOCATION);
+ DALI_TEST_EQUALS(height, testHeight, TEST_LOCATION);
END_TEST;
}
int UtcDaliSceneSurfaceResizedAdditionalScene(void)
{
- tet_infoline( "Ensure resizing of the surface is handled properly on additional scenes" );
+ tet_infoline("Ensure resizing of the surface is handled properly on additional scenes");
TestApplication application;
- Vector2 originalSurfaceSize( 500.0f, 1000.0f );
+ Vector2 originalSurfaceSize(500.0f, 1000.0f);
- auto scene = Integration::Scene::New( Size( originalSurfaceSize.width, originalSurfaceSize.height ) );
+ auto scene = Integration::Scene::New(Size(originalSurfaceSize.width, originalSurfaceSize.height));
// Ensure stage size does NOT match the surface size
- auto stage = Stage::GetCurrent();
+ auto stage = Stage::GetCurrent();
const auto stageSize = stage.GetSize();
- DALI_TEST_CHECK( stageSize != originalSurfaceSize );
- DALI_TEST_EQUALS( originalSurfaceSize, scene.GetSize(), TEST_LOCATION );
+ DALI_TEST_CHECK(stageSize != originalSurfaceSize);
+ DALI_TEST_EQUALS(originalSurfaceSize, scene.GetSize(), TEST_LOCATION);
// Resize the surface and inform the scene accordingly
- Vector2 newSize( 1000.0f, 2000.0f );
- DALI_TEST_CHECK( stage.GetSize() != newSize );
- scene.SurfaceResized( newSize.width, newSize.height );
+ Vector2 newSize(1000.0f, 2000.0f);
+ DALI_TEST_CHECK(stage.GetSize() != newSize);
+ scene.SurfaceResized(newSize.width, newSize.height);
// Ensure the stage hasn't been resized
- DALI_TEST_EQUALS( stage.GetSize(), stageSize, TEST_LOCATION );
- DALI_TEST_EQUALS( scene.GetSize(), newSize, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetSize(), stageSize, TEST_LOCATION);
+ DALI_TEST_EQUALS(scene.GetSize(), newSize, TEST_LOCATION);
END_TEST;
}
int UtcDaliSceneKeyEventGeneratedSignalP(void)
{
- TestApplication application;
+ TestApplication application;
Dali::Integration::Scene scene = application.GetScene();
- KeyEventGeneratedSignalData data;
- KeyEventGeneratedReceivedFunctor functor( data );
- scene.KeyEventGeneratedSignal().Connect( &application, functor );
+ KeyEventGeneratedSignalData data;
+ KeyEventGeneratedReceivedFunctor functor(data);
+ scene.KeyEventGeneratedSignal().Connect(&application, functor);
- Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event );
+ Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event2( "i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event2 );
+ Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event2);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event3( "a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event3 );
+ Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event3);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event4( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event4 );
+ Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event4);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
END_TEST;
}
int UtcDaliSceneEnsureReplacedSurfaceKeepsClearColor(void)
{
- tet_infoline( "Ensure we keep background color when the scene surface is replaced " );
+ tet_infoline("Ensure we keep background color when the scene surface is replaced ");
TestApplication application;
// Create a new scene and set the background color of the main scene
auto defaultScene = application.GetScene();
- defaultScene.SetBackgroundColor( Color::BLUE );
+ defaultScene.SetBackgroundColor(Color::BLUE);
// Need to create a renderable as we don't start rendering until we have at least one
// We don't need to add this to any scene
auto actor = CreateRenderableActor();
- auto& glAbstraction = application.GetGlAbstraction();
- auto clearCountBefore = glAbstraction.GetClearCountCalled();
+ auto& glAbstraction = application.GetGlAbstraction();
+ auto clearCountBefore = glAbstraction.GetClearCountCalled();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION );
- DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
defaultScene.SurfaceReplaced();
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION );
- DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
// Check when the main render task viewport is set the clear color is clipped using scissors
- TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
+ TraceCallStack& scissorTrace = glAbstraction.GetScissorTrace();
TraceCallStack& enabledDisableTrace = glAbstraction.GetEnableDisableTrace();
- scissorTrace.Enable( true );
- enabledDisableTrace.Enable( true );
+ scissorTrace.Enable(true);
+ enabledDisableTrace.Enable(true);
- defaultScene.GetRenderTaskList().GetTask( 0 ).SetViewport( Viewport( 0.0f, 0.0f, 100.0f, 100.0f ) );
+ defaultScene.GetRenderTaskList().GetTask(0).SetViewport(Viewport(0.0f, 0.0f, 100.0f, 100.0f));
application.SendNotification();
application.Render();
// Check scissor test was enabled.
- DALI_TEST_CHECK( enabledDisableTrace.FindMethodAndParams( "Enable", "3089" ) ); // 3089 = 0xC11 (GL_SCISSOR_TEST)
+ DALI_TEST_CHECK(enabledDisableTrace.FindMethodAndParams("Enable", "3089")); // 3089 = 0xC11 (GL_SCISSOR_TEST)
// Check the scissor was set, and the coordinates are correct.
- DALI_TEST_CHECK( scissorTrace.FindMethodAndParams( "Scissor", "0, 700, 100, 100" ) );
+ DALI_TEST_CHECK(scissorTrace.FindMethodAndParams("Scissor", "0, 700, 100, 100"));
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION );
- DALI_TEST_EQUALS( glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), clearCountBefore + 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(glAbstraction.GetLastClearColor(), Color::BLUE, TEST_LOCATION);
- scissorTrace.Enable( false );
+ scissorTrace.Enable(false);
scissorTrace.Reset();
- enabledDisableTrace.Enable( false );
+ enabledDisableTrace.Enable(false);
enabledDisableTrace.Reset();
END_TEST;
int UtcDaliSceneEmptySceneRendering(void)
{
- tet_infoline( "Ensure not rendering before a Renderer is added" );
+ tet_infoline("Ensure not rendering before a Renderer is added");
- TestApplication application;
+ TestApplication application;
TestGlAbstraction& glAbstraction = application.GetGlAbstraction();
// Render without any renderer
application.Render();
// Check the clear count and the render status
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetRenderNeedsPostRender(), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), false, TEST_LOCATION);
// Add a Renderer
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
+ actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400, 400 ) );
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400, 400));
+ application.GetScene().Add(actor);
// Render
application.SendNotification();
application.Render();
// Check the clear count and the render status
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( application.GetRenderNeedsPostRender(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
// Remove the Renderer
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
actor.Reset();
renderer.Reset();
application.Render();
// Check the clear count and the render status
- DALI_TEST_EQUALS( glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION ); // Should be cleared
- DALI_TEST_EQUALS( application.GetRenderNeedsPostRender(), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(glAbstraction.GetClearCountCalled(), 2, TEST_LOCATION); // Should be cleared
+ DALI_TEST_EQUALS(application.GetRenderNeedsPostRender(), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliSceneFrameRenderedPresentedCallback(void)
{
- tet_infoline( "UtcDaliSceneFrameRenderedCallback" );
+ tet_infoline("UtcDaliSceneFrameRenderedCallback");
TestApplication application;
// Add a Renderer
Geometry geometry = CreateQuadGeometry();
- Shader shader = CreateShader();
- Renderer renderer = Renderer::New( geometry, shader );
+ Shader shader = CreateShader();
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
- actor.AddRenderer( renderer );
- application.GetScene().Add( actor );
+ actor.AddRenderer(renderer);
+ application.GetScene().Add(actor);
Dali::Integration::Scene scene = application.GetScene();
int frameId = 1;
- scene.AddFrameRenderedCallback( std::unique_ptr< CallbackBase >( MakeCallback( &FrameCallback ) ), frameId );
- scene.AddFramePresentedCallback( std::unique_ptr< CallbackBase >( MakeCallback( &FrameCallback ) ), frameId );
+ scene.AddFrameRenderedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
+ scene.AddFramePresentedCallback(std::unique_ptr<CallbackBase>(MakeCallback(&FrameCallback)), frameId);
// Render
application.SendNotification();
application.Render();
Dali::Integration::Scene::FrameCallbackContainer callbackContainer;
- scene.GetFrameRenderedCallback( callbackContainer );
+ scene.GetFrameRenderedCallback(callbackContainer);
- DALI_TEST_EQUALS( callbackContainer.size(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( callbackContainer[0].second, frameId, TEST_LOCATION );
+ DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
callbackContainer.clear();
- scene.GetFramePresentedCallback( callbackContainer );
+ scene.GetFramePresentedCallback(callbackContainer);
- DALI_TEST_EQUALS( callbackContainer.size(), 1, TEST_LOCATION );
- DALI_TEST_EQUALS( callbackContainer[0].second, frameId, TEST_LOCATION );
+ DALI_TEST_EQUALS(callbackContainer.size(), 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(callbackContainer[0].second, frameId, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/scripting/scripting.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/scripting/scripting.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
using namespace Dali::Scripting;
namespace
{
-
const StringEnum COLOR_MODE_VALUES[] =
-{
- { "USE_OWN_COLOR", USE_OWN_COLOR },
- { "USE_PARENT_COLOR", USE_PARENT_COLOR },
- { "USE_OWN_MULTIPLY_PARENT_COLOR", USE_OWN_MULTIPLY_PARENT_COLOR },
- { "USE_OWN_MULTIPLY_PARENT_ALPHA", USE_OWN_MULTIPLY_PARENT_ALPHA },
+ {
+ {"USE_OWN_COLOR", USE_OWN_COLOR},
+ {"USE_PARENT_COLOR", USE_PARENT_COLOR},
+ {"USE_OWN_MULTIPLY_PARENT_COLOR", USE_OWN_MULTIPLY_PARENT_COLOR},
+ {"USE_OWN_MULTIPLY_PARENT_ALPHA", USE_OWN_MULTIPLY_PARENT_ALPHA},
};
-const unsigned int COLOR_MODE_VALUES_COUNT = sizeof( COLOR_MODE_VALUES ) / sizeof( COLOR_MODE_VALUES[0] );
+const unsigned int COLOR_MODE_VALUES_COUNT = sizeof(COLOR_MODE_VALUES) / sizeof(COLOR_MODE_VALUES[0]);
const StringEnum DRAW_MODE_VALUES[] =
-{
- { "NORMAL", DrawMode::NORMAL },
- { "OVERLAY_2D", DrawMode::OVERLAY_2D }
-};
-const unsigned int DRAW_MODE_VALUES_COUNT = sizeof( DRAW_MODE_VALUES ) / sizeof( DRAW_MODE_VALUES[0] );
-
+ {
+ {"NORMAL", DrawMode::NORMAL},
+ {"OVERLAY_2D", DrawMode::OVERLAY_2D}};
+const unsigned int DRAW_MODE_VALUES_COUNT = sizeof(DRAW_MODE_VALUES) / sizeof(DRAW_MODE_VALUES[0]);
////////////////////////////////////////////////////////////////////////////////
// Helpers for string to enum comparisons for Image and Image loading parameters
/**
* Template to check enumerations of type T, with a class of type X
*/
-template< typename T, typename X >
+template<typename T, typename X>
void TestEnumStrings(
- Property::Map& map, // The map used to create instance of type X
- const char * const keyName, // the name of the key to iterate through
- const StringEnum* values, // An array of string values
- unsigned int num, // Number of items in the array
- T ( X::*method )() const, // The member method of X to call to get the enum
- X ( *creator ) ( const Property::Value& ) // The method which creates an instance of type X
+ Property::Map& map, // The map used to create instance of type X
+ const char* const keyName, // the name of the key to iterate through
+ const StringEnum* values, // An array of string values
+ unsigned int num, // Number of items in the array
+ T (X::*method)() const, // The member method of X to call to get the enum
+ X (*creator)(const Property::Value&) // The method which creates an instance of type X
)
{
// get the key reference so we can change its value
- Property::Value* value = map.Find( keyName );
- for ( unsigned int i = 0; i < num; ++i )
+ Property::Value* value = map.Find(keyName);
+ for(unsigned int i = 0; i < num; ++i)
{
*value = values[i].string;
- tet_printf("Checking: %s: %s\n", keyName, values[i].string );
- X instance = creator( map );
- DALI_TEST_EQUALS( values[i].value, (int)( instance.*method )(), TEST_LOCATION );
+ tet_printf("Checking: %s: %s\n", keyName, values[i].string);
+ X instance = creator(map);
+ DALI_TEST_EQUALS(values[i].value, (int)(instance.*method)(), TEST_LOCATION);
}
}
/**
* Template to check enumerations of type T
*/
-template< typename T >
+template<typename T>
void TestEnumStrings(
- const char * const keyName, // The name of the key to check
- TestApplication& application, // Reference to the application class
- const StringEnum* values, // An array of string values
- unsigned int num, // Number of items in the array
- void ( Actor::*method )( T ) // The Actor member method to set the enumeration
+ const char* const keyName, // The name of the key to check
+ TestApplication& application, // Reference to the application class
+ const StringEnum* values, // An array of string values
+ unsigned int num, // Number of items in the array
+ void (Actor::*method)(T) // The Actor member method to set the enumeration
)
{
- for ( unsigned int i = 0; i < num; ++i )
+ for(unsigned int i = 0; i < num; ++i)
{
- tet_printf("Checking: %s: %s\n", keyName, values[i].string );
+ tet_printf("Checking: %s: %s\n", keyName, values[i].string);
Actor actor = Actor::New();
- (actor.*method)( ( T ) values[i].value );
+ (actor.*method)((T)values[i].value);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
Property::Map map;
- CreatePropertyMap( actor, map );
+ CreatePropertyMap(actor, map);
- DALI_TEST_CHECK( 0 < map.Count() );
- DALI_TEST_CHECK( NULL != map.Find( keyName ) );
- DALI_TEST_EQUALS( map.Find( keyName )->Get< std::string >(), values[i].string, TEST_LOCATION );
+ DALI_TEST_CHECK(0 < map.Count());
+ DALI_TEST_CHECK(NULL != map.Find(keyName));
+ DALI_TEST_EQUALS(map.Find(keyName)->Get<std::string>(), values[i].string, TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
}
}
//////////////////////////////////////////////////////////////////////////////
-
-} // anon namespace
+} // namespace
int UtcDaliValueFromEnum(void)
{
- enum class T {
- None, V1 = 1, V2 = 2
+ enum class T
+ {
+ None,
+ V1 = 1,
+ V2 = 2
};
Property::Value v1 = T::V1;
Property::Value v2 = T::V2;
T t = T::None;
- DALI_TEST_CHECK( v1.Get<T>() == T::V1 );
- DALI_TEST_CHECK( v2.Get<T>() == T::V2 );
- DALI_TEST_CHECK( v1.Get(t) && t == T::V1 );
- DALI_TEST_CHECK( v2.Get(t) && t == T::V2 );
+ DALI_TEST_CHECK(v1.Get<T>() == T::V1);
+ DALI_TEST_CHECK(v2.Get<T>() == T::V2);
+ DALI_TEST_CHECK(v1.Get(t) && t == T::V1);
+ DALI_TEST_CHECK(v2.Get(t) && t == T::V2);
END_TEST;
}
// Empty map
{
- Actor handle = NewActor( Property::Map() );
- DALI_TEST_CHECK( !handle );
+ Actor handle = NewActor(Property::Map());
+ DALI_TEST_CHECK(!handle);
}
// Map with only properties
{
Property::Map map;
- map[ "parentOrigin" ] = ParentOrigin::TOP_CENTER;
- map[ "anchorPoint" ] = AnchorPoint::TOP_CENTER;
- Actor handle = NewActor( map );
- DALI_TEST_CHECK( !handle );
+ map["parentOrigin"] = ParentOrigin::TOP_CENTER;
+ map["anchorPoint"] = AnchorPoint::TOP_CENTER;
+ Actor handle = NewActor(map);
+ DALI_TEST_CHECK(!handle);
}
// Add some signals to the map, we should have no signal connections as its not yet supported
{
Property::Map map;
- map[ "type" ] = "Actor";
- map[ "signals" ] = Property::MAP;
- Actor handle = NewActor( map );
- DALI_TEST_CHECK( handle );
- DALI_TEST_CHECK( !handle.WheelEventSignal().GetConnectionCount() );
- DALI_TEST_CHECK( !handle.OffSceneSignal().GetConnectionCount() );
- DALI_TEST_CHECK( !handle.OnSceneSignal().GetConnectionCount() );
- DALI_TEST_CHECK( !handle.TouchedSignal().GetConnectionCount() );
+ map["type"] = "Actor";
+ map["signals"] = Property::MAP;
+ Actor handle = NewActor(map);
+ DALI_TEST_CHECK(handle);
+ DALI_TEST_CHECK(!handle.WheelEventSignal().GetConnectionCount());
+ DALI_TEST_CHECK(!handle.OffSceneSignal().GetConnectionCount());
+ DALI_TEST_CHECK(!handle.OnSceneSignal().GetConnectionCount());
+ DALI_TEST_CHECK(!handle.TouchedSignal().GetConnectionCount());
}
END_TEST;
}
TestApplication application;
Property::Map map;
- map[ "type" ] = "Actor";
- map[ "size" ] = Vector3::ONE;
- map[ "position" ] = Vector3::XAXIS;
- map[ "scale" ] = Vector3::ONE;
- map[ "visible" ] = false;
- map[ "color" ] = Color::MAGENTA;
- map[ "name" ] = "MyActor";
- map[ "colorMode" ] = "USE_PARENT_COLOR";
- map[ "sensitive" ] = false;
- map[ "leaveRequired" ] = true;
- map[ "drawMode" ] = "OVERLAY_2D";
- map[ "inheritOrientation" ] = false;
- map[ "inheritScale" ] = false;
+ map["type"] = "Actor";
+ map["size"] = Vector3::ONE;
+ map["position"] = Vector3::XAXIS;
+ map["scale"] = Vector3::ONE;
+ map["visible"] = false;
+ map["color"] = Color::MAGENTA;
+ map["name"] = "MyActor";
+ map["colorMode"] = "USE_PARENT_COLOR";
+ map["sensitive"] = false;
+ map["leaveRequired"] = true;
+ map["drawMode"] = "OVERLAY_2D";
+ map["inheritOrientation"] = false;
+ map["inheritScale"] = false;
// Default properties
{
- Actor handle = NewActor( map );
- DALI_TEST_CHECK( handle );
+ Actor handle = NewActor(map);
+ DALI_TEST_CHECK(handle);
- application.GetScene().Add( handle );
+ application.GetScene().Add(handle);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::SIZE ), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::XAXIS, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::SCALE ), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetCurrentProperty< bool >( Actor::Property::VISIBLE ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::MAGENTA, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< std::string >( Actor::Property::NAME ), "MyActor", TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< ColorMode >( Actor::Property::COLOR_MODE ), USE_PARENT_COLOR, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< bool >( Actor::Property::SENSITIVE ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< bool >( Actor::Property::LEAVE_REQUIRED ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE ), DrawMode::OVERLAY_2D, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetProperty< bool >( Actor::Property::INHERIT_SCALE ), false, TEST_LOCATION );
-
- application.GetScene().Remove( handle );
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::SIZE), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::XAXIS, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::SCALE), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<bool>(Actor::Property::VISIBLE), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<std::string>(Actor::Property::NAME), "MyActor", TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<ColorMode>(Actor::Property::COLOR_MODE), USE_PARENT_COLOR, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(Actor::Property::SENSITIVE), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(Actor::Property::LEAVE_REQUIRED), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<DrawMode::Type>(Actor::Property::DRAW_MODE), DrawMode::OVERLAY_2D, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(Actor::Property::INHERIT_ORIENTATION), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetProperty<bool>(Actor::Property::INHERIT_SCALE), false, TEST_LOCATION);
+
+ application.GetScene().Remove(handle);
}
// Check Anchor point and parent origin vector3s
- map[ "parentOrigin" ] = ParentOrigin::TOP_CENTER;
- map[ "anchorPoint" ] = AnchorPoint::TOP_LEFT;
+ map["parentOrigin"] = ParentOrigin::TOP_CENTER;
+ map["anchorPoint"] = AnchorPoint::TOP_LEFT;
{
- Actor handle = NewActor( map );
- DALI_TEST_CHECK( handle );
+ Actor handle = NewActor(map);
+ DALI_TEST_CHECK(handle);
- application.GetScene().Add( handle );
+ application.GetScene().Add(handle);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_CENTER, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), AnchorPoint::TOP_LEFT, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_CENTER, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), AnchorPoint::TOP_LEFT, TEST_LOCATION);
- application.GetScene().Remove( handle );
+ application.GetScene().Remove(handle);
}
// Check Anchor point and parent origin STRINGS
- map[ "parentOrigin" ] = "TOP_LEFT";
- map[ "anchorPoint" ] = "CENTER_LEFT";
+ map["parentOrigin"] = "TOP_LEFT";
+ map["anchorPoint"] = "CENTER_LEFT";
{
- Actor handle = NewActor( map );
- DALI_TEST_CHECK( handle );
+ Actor handle = NewActor(map);
+ DALI_TEST_CHECK(handle);
- application.GetScene().Add( handle );
+ application.GetScene().Add(handle);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN ), ParentOrigin::TOP_LEFT, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT ), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::PARENT_ORIGIN), ParentOrigin::TOP_LEFT, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::ANCHOR_POINT), AnchorPoint::CENTER_LEFT, TEST_LOCATION);
- application.GetScene().Remove( handle );
+ application.GetScene().Remove(handle);
}
END_TEST;
}
TestApplication application;
Property::Map map;
- map["actor"] = "Actor1";
- map["property"] = "color";
- map["value"] = Color::MAGENTA;
+ map["actor"] = "Actor1";
+ map["property"] = "color";
+ map["value"] = Color::MAGENTA;
map["alphaFunction"] = "EASE_IN_OUT";
Property::Map timePeriod;
- timePeriod["delay"] = 0.5f;
+ timePeriod["delay"] = 0.5f;
timePeriod["duration"] = 1.0f;
- map["timePeriod"] = timePeriod;
+ map["timePeriod"] = timePeriod;
Dali::AnimationData data;
- Scripting::NewAnimation( map, data );
+ Scripting::NewAnimation(map, data);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::NAME,"Actor1");
- actor.SetProperty( Actor::Property::COLOR,Color::CYAN);
+ actor.SetProperty(Actor::Property::NAME, "Actor1");
+ actor.SetProperty(Actor::Property::COLOR, Color::CYAN);
application.GetScene().Add(actor);
- Animation anim = data.CreateAnimation( actor, 0.5f );
+ Animation anim = data.CreateAnimation(actor, 0.5f);
anim.Play();
application.SendNotification();
application.Render(500); // Start animation
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), (Color::MAGENTA+Color::CYAN)*0.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), (Color::MAGENTA + Color::CYAN) * 0.5f, TEST_LOCATION);
application.Render(500); // Halfway thru anim
application.SendNotification();
- DALI_TEST_EQUALS( actor.GetCurrentProperty< Vector4 >( Actor::Property::COLOR ), Color::MAGENTA, TEST_LOCATION );
+ DALI_TEST_EQUALS(actor.GetCurrentProperty<Vector4>(Actor::Property::COLOR), Color::MAGENTA, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Property::Map map;
- map[ "type" ] = "Actor";
- map[ "position" ] = Vector3::XAXIS;
+ map["type"] = "Actor";
+ map["position"] = Vector3::XAXIS;
Property::Map child1Map;
- child1Map[ "type" ] = "Layer";
- child1Map[ "position" ] = Vector3::YAXIS;
+ child1Map["type"] = "Layer";
+ child1Map["position"] = Vector3::YAXIS;
Property::Array childArray;
- childArray.PushBack( child1Map );
- map[ "actors" ] = childArray;
+ childArray.PushBack(child1Map);
+ map["actors"] = childArray;
// Create
- Actor handle = NewActor( map );
- DALI_TEST_CHECK( handle );
+ Actor handle = NewActor(map);
+ DALI_TEST_CHECK(handle);
- application.GetScene().Add( handle );
+ application.GetScene().Add(handle);
application.SendNotification();
application.Render();
- DALI_TEST_EQUALS( handle.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::XAXIS, TEST_LOCATION );
- DALI_TEST_EQUALS( handle.GetChildCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(handle.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::XAXIS, TEST_LOCATION);
+ DALI_TEST_EQUALS(handle.GetChildCount(), 1u, TEST_LOCATION);
Actor child1 = handle.GetChildAt(0);
- DALI_TEST_CHECK( child1 );
- DALI_TEST_CHECK( Layer::DownCast( child1 ) );
- DALI_TEST_EQUALS( child1.GetCurrentProperty< Vector3 >( Actor::Property::POSITION ), Vector3::YAXIS, TEST_LOCATION );
- DALI_TEST_EQUALS( child1.GetChildCount(), 0u, TEST_LOCATION );
+ DALI_TEST_CHECK(child1);
+ DALI_TEST_CHECK(Layer::DownCast(child1));
+ DALI_TEST_EQUALS(child1.GetCurrentProperty<Vector3>(Actor::Property::POSITION), Vector3::YAXIS, TEST_LOCATION);
+ DALI_TEST_EQUALS(child1.GetChildCount(), 0u, TEST_LOCATION);
- application.GetScene().Remove( handle );
+ application.GetScene().Remove(handle);
END_TEST;
}
-
int UtcDaliScriptingCreatePropertyMapActor(void)
{
TestApplication application;
Actor actor = Actor::New();
Property::Map map;
- CreatePropertyMap( actor, map );
- DALI_TEST_CHECK( !map.Empty() );
- DALI_TEST_CHECK( NULL != map.Find( "type" ) );
- DALI_TEST_EQUALS( map.Find( "type")->Get< std::string >(), "Actor", TEST_LOCATION );
+ CreatePropertyMap(actor, map);
+ DALI_TEST_CHECK(!map.Empty());
+ DALI_TEST_CHECK(NULL != map.Find("type"));
+ DALI_TEST_EQUALS(map.Find("type")->Get<std::string>(), "Actor", TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
}
// Layer Type
Actor actor = Layer::New();
Property::Map map;
- CreatePropertyMap( actor, map );
- DALI_TEST_CHECK( !map.Empty() );
- DALI_TEST_CHECK( NULL != map.Find( "type" ) );
- DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "Layer", TEST_LOCATION );
+ CreatePropertyMap(actor, map);
+ DALI_TEST_CHECK(!map.Empty());
+ DALI_TEST_CHECK(NULL != map.Find("type"));
+ DALI_TEST_EQUALS(map.Find("type")->Get<std::string>(), "Layer", TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
}
// Default properties
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector3::ONE );
- actor.SetProperty( Actor::Property::POSITION, Vector3::XAXIS );
- actor.SetProperty( Actor::Property::SCALE, Vector3::ZAXIS );
- actor.SetProperty( Actor::Property::VISIBLE, false );
- actor.SetProperty( Actor::Property::COLOR, Color::MAGENTA );
- actor.SetProperty( Actor::Property::NAME, "MyActor" );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT );
- actor.SetProperty( Actor::Property::SENSITIVE, false );
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
- actor.SetProperty( Actor::Property::INHERIT_ORIENTATION, false );
- actor.SetProperty( Actor::Property::INHERIT_SCALE, false );
- actor.SetProperty( Actor::Property::SIZE_MODE_FACTOR, Vector3::ONE );
-
- application.GetScene().Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE);
+ actor.SetProperty(Actor::Property::POSITION, Vector3::XAXIS);
+ actor.SetProperty(Actor::Property::SCALE, Vector3::ZAXIS);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
+ actor.SetProperty(Actor::Property::COLOR, Color::MAGENTA);
+ actor.SetProperty(Actor::Property::NAME, "MyActor");
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_RIGHT);
+ actor.SetProperty(Actor::Property::SENSITIVE, false);
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
+ actor.SetProperty(Actor::Property::INHERIT_ORIENTATION, false);
+ actor.SetProperty(Actor::Property::INHERIT_SCALE, false);
+ actor.SetProperty(Actor::Property::SIZE_MODE_FACTOR, Vector3::ONE);
+
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
Property::Map map;
- CreatePropertyMap( actor, map );
-
- DALI_TEST_CHECK( !map.Empty() );
- DALI_TEST_CHECK( NULL != map.Find( "size" ) );
- DALI_TEST_EQUALS( map.Find( "size" )->Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "position" ) );
- DALI_TEST_EQUALS( map.Find( "position" )->Get< Vector3 >(), Vector3::XAXIS, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "scale" ) );
- DALI_TEST_EQUALS( map.Find( "scale" )->Get< Vector3 >(), Vector3::ZAXIS, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "visible" ) );
- DALI_TEST_EQUALS( map.Find( "visible" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "color" ) );
- DALI_TEST_EQUALS( map.Find( "color" )->Get< Vector4 >(), Color::MAGENTA, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "name" ) );
- DALI_TEST_EQUALS( map.Find( "name")->Get< std::string >(), "MyActor", TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "anchorPoint" ) );
- DALI_TEST_EQUALS( map.Find( "anchorPoint" )->Get< Vector3 >(), AnchorPoint::CENTER_LEFT, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "parentOrigin" ) );
- DALI_TEST_EQUALS( map.Find( "parentOrigin" )->Get< Vector3 >(), ParentOrigin::TOP_RIGHT, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "sensitive" ) );
- DALI_TEST_EQUALS( map.Find( "sensitive" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "leaveRequired" ) );
- DALI_TEST_EQUALS( map.Find( "leaveRequired" )->Get< bool >(), true, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "inheritOrientation" ) );
- DALI_TEST_EQUALS( map.Find( "inheritOrientation" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "inheritScale" ) );
- DALI_TEST_EQUALS( map.Find( "inheritScale" )->Get< bool >(), false, TEST_LOCATION );
- DALI_TEST_CHECK( NULL != map.Find( "sizeModeFactor" ) );
- DALI_TEST_EQUALS( map.Find( "sizeModeFactor" )->Get< Vector3 >(), Vector3::ONE, TEST_LOCATION );
-
- application.GetScene().Remove( actor );
+ CreatePropertyMap(actor, map);
+
+ DALI_TEST_CHECK(!map.Empty());
+ DALI_TEST_CHECK(NULL != map.Find("size"));
+ DALI_TEST_EQUALS(map.Find("size")->Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("position"));
+ DALI_TEST_EQUALS(map.Find("position")->Get<Vector3>(), Vector3::XAXIS, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("scale"));
+ DALI_TEST_EQUALS(map.Find("scale")->Get<Vector3>(), Vector3::ZAXIS, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("visible"));
+ DALI_TEST_EQUALS(map.Find("visible")->Get<bool>(), false, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("color"));
+ DALI_TEST_EQUALS(map.Find("color")->Get<Vector4>(), Color::MAGENTA, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("name"));
+ DALI_TEST_EQUALS(map.Find("name")->Get<std::string>(), "MyActor", TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("anchorPoint"));
+ DALI_TEST_EQUALS(map.Find("anchorPoint")->Get<Vector3>(), AnchorPoint::CENTER_LEFT, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("parentOrigin"));
+ DALI_TEST_EQUALS(map.Find("parentOrigin")->Get<Vector3>(), ParentOrigin::TOP_RIGHT, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("sensitive"));
+ DALI_TEST_EQUALS(map.Find("sensitive")->Get<bool>(), false, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("leaveRequired"));
+ DALI_TEST_EQUALS(map.Find("leaveRequired")->Get<bool>(), true, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("inheritOrientation"));
+ DALI_TEST_EQUALS(map.Find("inheritOrientation")->Get<bool>(), false, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("inheritScale"));
+ DALI_TEST_EQUALS(map.Find("inheritScale")->Get<bool>(), false, TEST_LOCATION);
+ DALI_TEST_CHECK(NULL != map.Find("sizeModeFactor"));
+ DALI_TEST_EQUALS(map.Find("sizeModeFactor")->Get<Vector3>(), Vector3::ONE, TEST_LOCATION);
+
+ application.GetScene().Remove(actor);
}
// Children
{
Actor actor = Actor::New();
Actor child = Layer::New();
- actor.Add( child );
+ actor.Add(child);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
application.SendNotification();
application.Render();
Property::Map map;
- CreatePropertyMap( actor, map );
- DALI_TEST_CHECK( !map.Empty() );
+ CreatePropertyMap(actor, map);
+ DALI_TEST_CHECK(!map.Empty());
- DALI_TEST_CHECK( NULL != map.Find( "type" ) );
- DALI_TEST_EQUALS( map.Find( "type" )->Get< std::string >(), "Actor", TEST_LOCATION );
+ DALI_TEST_CHECK(NULL != map.Find("type"));
+ DALI_TEST_EQUALS(map.Find("type")->Get<std::string>(), "Actor", TEST_LOCATION);
- DALI_TEST_CHECK( NULL != map.Find( "actors" ) );
- Property::Array children( map.Find( "actors")->Get< Property::Array >() );
- DALI_TEST_CHECK( !children.Empty() );
- Property::Map childMap( children[0].Get< Property::Map >() );
- DALI_TEST_CHECK( !childMap.Empty() );
- DALI_TEST_CHECK( childMap.Find( "type" ) );
- DALI_TEST_EQUALS( childMap.Find( "type" )->Get< std::string >(), "Layer", TEST_LOCATION );
+ DALI_TEST_CHECK(NULL != map.Find("actors"));
+ Property::Array children(map.Find("actors")->Get<Property::Array>());
+ DALI_TEST_CHECK(!children.Empty());
+ Property::Map childMap(children[0].Get<Property::Map>());
+ DALI_TEST_CHECK(!childMap.Empty());
+ DALI_TEST_CHECK(childMap.Find("type"));
+ DALI_TEST_EQUALS(childMap.Find("type")->Get<std::string>(), "Layer", TEST_LOCATION);
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
}
END_TEST;
}
int UtcDaliScriptingGetEnumerationTemplates(void)
{
const Scripting::StringEnum myTable[] =
- {
- { "ONE", 1 },
- { "TWO", 2 },
- { "THREE", 3 },
- { "FOUR", 4 },
- { "FIVE", 5 },
- };
- const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+ {
+ {"ONE", 1},
+ {"TWO", 2},
+ {"THREE", 3},
+ {"FOUR", 4},
+ {"FIVE", 5},
+ };
+ const unsigned int myTableCount = sizeof(myTable) / sizeof(myTable[0]);
- for ( unsigned int i = 0; i < myTableCount; ++i )
+ for(unsigned int i = 0; i < myTableCount; ++i)
{
- tet_printf("Checking: %s\n", myTable[ i ].string );
+ tet_printf("Checking: %s\n", myTable[i].string);
int value;
- DALI_TEST_CHECK( GetEnumeration<int>( myTable[ i ].string, myTable, myTableCount, value ) );
- DALI_TEST_EQUALS( myTable[ i ].value, value, TEST_LOCATION );
+ DALI_TEST_CHECK(GetEnumeration<int>(myTable[i].string, myTable, myTableCount, value));
+ DALI_TEST_EQUALS(myTable[i].value, value, TEST_LOCATION);
}
- for ( unsigned int i = 0; i < myTableCount; ++i )
+ for(unsigned int i = 0; i < myTableCount; ++i)
{
- tet_printf("Checking: %d\n", myTable[ i ].value );
- DALI_TEST_EQUALS( myTable[ i ].string, GetEnumerationName( myTable[ i ].value, myTable, myTableCount ), TEST_LOCATION );
+ tet_printf("Checking: %d\n", myTable[i].value);
+ DALI_TEST_EQUALS(myTable[i].string, GetEnumerationName(myTable[i].value, myTable, myTableCount), TEST_LOCATION);
}
END_TEST;
int UtcDaliScriptingGetEnumerationNameN(void)
{
- const char* value = GetEnumerationName( 10, NULL, 0 );
- DALI_TEST_CHECK( NULL == value );
+ const char* value = GetEnumerationName(10, NULL, 0);
+ DALI_TEST_CHECK(NULL == value);
- value = GetEnumerationName( 10, NULL, 1 );
- DALI_TEST_CHECK( NULL == value );
+ value = GetEnumerationName(10, NULL, 1);
+ DALI_TEST_CHECK(NULL == value);
END_TEST;
}
int UtcDaliScriptingGetLinearEnumerationNameN(void)
{
- const char* value = GetLinearEnumerationName( 10, NULL, 0 );
- DALI_TEST_CHECK( NULL == value );
+ const char* value = GetLinearEnumerationName(10, NULL, 0);
+ DALI_TEST_CHECK(NULL == value);
- value = GetLinearEnumerationName( 10, NULL, 1 );
- DALI_TEST_CHECK( NULL == value );
+ value = GetLinearEnumerationName(10, NULL, 1);
+ DALI_TEST_CHECK(NULL == value);
END_TEST;
}
*/
// String to Enum property table to test with (equivalent to ones used within DALi).
- const Dali::Scripting::StringEnum testTable[] = {
- { "NONE", FaceCullingMode::NONE },
- { "FRONT", FaceCullingMode::FRONT },
- { "BACK", FaceCullingMode::BACK },
- { "FRONT_AND_BACK", FaceCullingMode::FRONT_AND_BACK }
- }; const unsigned int testTableCount = sizeof( testTable ) / sizeof( testTable[0] );
+ const Dali::Scripting::StringEnum testTable[] = {
+ {"NONE", FaceCullingMode::NONE},
+ {"FRONT", FaceCullingMode::FRONT},
+ {"BACK", FaceCullingMode::BACK},
+ {"FRONT_AND_BACK", FaceCullingMode::FRONT_AND_BACK}};
+ const unsigned int testTableCount = sizeof(testTable) / sizeof(testTable[0]);
// TEST: An enum can be looked up from a Property::Value of type INTEGER.
// Initialise to first element.
FaceCullingMode::Type result = FaceCullingMode::NONE;
// Set the input property value to a different value (to emulate a change).
- Property::Value propertyValueInteger( FaceCullingMode::FRONT );
+ Property::Value propertyValueInteger(FaceCullingMode::FRONT);
// Perform the lookup.
- bool returnValue = GetEnumerationProperty< FaceCullingMode::Type >( propertyValueInteger, testTable, testTableCount, result );
+ bool returnValue = GetEnumerationProperty<FaceCullingMode::Type>(propertyValueInteger, testTable, testTableCount, result);
// TEST: The return value is "true" if the property can be successfully converted AND it has changed
// Check the property could be converted.
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::FRONT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::FRONT), TEST_LOCATION);
// Now emulate a property-set with the same value. false should be returned.
- returnValue = GetEnumerationProperty< FaceCullingMode::Type >( propertyValueInteger, testTable, testTableCount, result );
+ returnValue = GetEnumerationProperty<FaceCullingMode::Type>(propertyValueInteger, testTable, testTableCount, result);
// TEST: The return value is "false" if the property can be successfully converted BUT it has NOT changed.
- DALI_TEST_CHECK( !returnValue );
+ DALI_TEST_CHECK(!returnValue);
// The result should remain the same.
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::FRONT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::FRONT), TEST_LOCATION);
// TEST: An enum can be looked up from a Property::Value of type STRING.
// Set the input property value to a different value (to emulate a change).
- Property::Value propertyValueString( "BACK" );
+ Property::Value propertyValueString("BACK");
- returnValue = GetEnumerationProperty< FaceCullingMode::Type >( propertyValueString, testTable, testTableCount, result );
+ returnValue = GetEnumerationProperty<FaceCullingMode::Type>(propertyValueString, testTable, testTableCount, result);
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
// The result should remain the same.
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::BACK ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::BACK), TEST_LOCATION);
- returnValue = GetEnumerationProperty< FaceCullingMode::Type >( propertyValueString, testTable, testTableCount, result );
+ returnValue = GetEnumerationProperty<FaceCullingMode::Type>(propertyValueString, testTable, testTableCount, result);
- DALI_TEST_CHECK( !returnValue );
+ DALI_TEST_CHECK(!returnValue);
// The result should remain the same.
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::BACK ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::BACK), TEST_LOCATION);
// TEST: An enum can NOT be looked up for other Property::Value types.
- Property::Value propertyValueBoolean( true );
+ Property::Value propertyValueBoolean(true);
- returnValue = GetEnumerationProperty< FaceCullingMode::Type >( propertyValueBoolean, testTable, testTableCount, result );
+ returnValue = GetEnumerationProperty<FaceCullingMode::Type>(propertyValueBoolean, testTable, testTableCount, result);
// TEST: The return value is "false" if the property can not be successfully converted.
// Return value should be false as Property::Value was of an unsupported type for enum properties.
- DALI_TEST_CHECK( !returnValue );
+ DALI_TEST_CHECK(!returnValue);
// TEST: The result value is only updated if the return value is "true" (IE. successful conversion and property value has changed).
// The result should remain the same.
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::BACK ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::BACK), TEST_LOCATION);
END_TEST;
}
*/
// String to Enum property table to test with (equivalent to ones used within DALi).
- const Dali::Scripting::StringEnum testTable[] = {
- { "NONE", FaceCullingMode::NONE },
- { "FRONT", FaceCullingMode::FRONT },
- { "BACK", FaceCullingMode::BACK },
- { "FRONT_AND_BACK", FaceCullingMode::FRONT_AND_BACK }
- }; const unsigned int testTableCount = sizeof( testTable ) / sizeof( testTable[0] );
+ const Dali::Scripting::StringEnum testTable[] = {
+ {"NONE", FaceCullingMode::NONE},
+ {"FRONT", FaceCullingMode::FRONT},
+ {"BACK", FaceCullingMode::BACK},
+ {"FRONT_AND_BACK", FaceCullingMode::FRONT_AND_BACK}};
+ const unsigned int testTableCount = sizeof(testTable) / sizeof(testTable[0]);
// TEST: An enum can be looked up from a Property::Value of type INTEGER.
// Initialise to first element.
FaceCullingMode::Type result = FaceCullingMode::NONE;
// Set the input property value to a different value (to emulate a change).
- Property::Value propertyValueInteger( FaceCullingMode::FRONT );
+ Property::Value propertyValueInteger(FaceCullingMode::FRONT);
// Perform the lookup.
- bool returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyValueInteger, testTable, testTableCount, result );
+ bool returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyValueInteger, testTable, testTableCount, result);
// TEST: The return value is "true" if the property can be successfully converted AND it has changed
// Check the property could be converted.
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::FRONT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::FRONT), TEST_LOCATION);
// TEST: An enum can be looked up from a Property::Value of type STRING.
// Set the input property value to a different value (to emulate a change).
- Property::Value propertyValueString( "BACK" );
+ Property::Value propertyValueString("BACK");
- returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyValueString, testTable, testTableCount, result );
+ returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyValueString, testTable, testTableCount, result);
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::BACK ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::BACK), TEST_LOCATION);
// TEST: An enum can NOT be looked up from other Property::Value types.
- Property::Value propertyValueVector( Vector3::ZERO );
+ Property::Value propertyValueVector(Vector3::ZERO);
- returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyValueVector, testTable, testTableCount, result );
+ returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyValueVector, testTable, testTableCount, result);
// TEST: The return value is "false" if the property can not be successfully converted.
// Return value should be false as Property::Value was of an unsupported type for enum properties.
- DALI_TEST_CHECK( !returnValue );
+ DALI_TEST_CHECK(!returnValue);
// TEST: The result value is only updated if the return value is "true" (IE. successful conversion and property value has changed).
// The result should remain the same.
- DALI_TEST_EQUALS( static_cast<int>( result ), static_cast<int>( FaceCullingMode::BACK ), TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<int>(result), static_cast<int>(FaceCullingMode::BACK), TEST_LOCATION);
// Test PropertyArrays:
// Property array of 2 integers.
Property::Array propertyArrayIntegers;
- propertyArrayIntegers.PushBack( FaceCullingMode::FRONT );
- propertyArrayIntegers.PushBack( FaceCullingMode::BACK );
+ propertyArrayIntegers.PushBack(FaceCullingMode::FRONT);
+ propertyArrayIntegers.PushBack(FaceCullingMode::BACK);
result = FaceCullingMode::NONE;
- returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyArrayIntegers, testTable, testTableCount, result );
+ returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyArrayIntegers, testTable, testTableCount, result);
// TEST: The return value when checking an array with 2 INTEGERS is "true" if the properties can be successfully converted.
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
// TEST: The result value when checking an array with 2 INTEGERS is the ORd value of the 2 integers.
- DALI_TEST_CHECK( result == ( FaceCullingMode::FRONT | FaceCullingMode::BACK ) );
+ DALI_TEST_CHECK(result == (FaceCullingMode::FRONT | FaceCullingMode::BACK));
// Property array of 2 strings.
Property::Array propertyArrayStrings;
- propertyArrayStrings.PushBack( "FRONT" );
- propertyArrayStrings.PushBack( "BACK" );
+ propertyArrayStrings.PushBack("FRONT");
+ propertyArrayStrings.PushBack("BACK");
result = FaceCullingMode::NONE;
- returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyArrayStrings, testTable, testTableCount, result );
+ returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyArrayStrings, testTable, testTableCount, result);
// TEST: The return value when checking an array with 2 STRINGS is "true" if the properties can be successfully converted.
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
// TEST: The result value when checking an array with 2 STRINGS is the ORd value of the 2 integer equivalents of the strings.
- DALI_TEST_CHECK( result == ( FaceCullingMode::FRONT | FaceCullingMode::BACK ) );
+ DALI_TEST_CHECK(result == (FaceCullingMode::FRONT | FaceCullingMode::BACK));
// Property array of an int and a string.
Property::Array propertyArrayMixed;
- propertyArrayMixed.PushBack( FaceCullingMode::FRONT );
- propertyArrayMixed.PushBack( "BACK" );
+ propertyArrayMixed.PushBack(FaceCullingMode::FRONT);
+ propertyArrayMixed.PushBack("BACK");
result = FaceCullingMode::NONE;
- returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyArrayMixed, testTable, testTableCount, result );
+ returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyArrayMixed, testTable, testTableCount, result);
// TEST: The return value when checking an array with an INTEGER and a STRING is "true" if the properties can be successfully converted.
- DALI_TEST_CHECK( returnValue );
+ DALI_TEST_CHECK(returnValue);
// TEST: The result value when checking an array with an INTEGER and a STRING is the ORd value of the 2 integer equivalents of the strings.
- DALI_TEST_CHECK( result == ( FaceCullingMode::FRONT | FaceCullingMode::BACK ) );
+ DALI_TEST_CHECK(result == (FaceCullingMode::FRONT | FaceCullingMode::BACK));
// Property array of an int and a string.
Property::Array propertyArrayInvalid;
- propertyArrayInvalid.PushBack( FaceCullingMode::FRONT );
- propertyArrayInvalid.PushBack( Vector3::ZERO );
+ propertyArrayInvalid.PushBack(FaceCullingMode::FRONT);
+ propertyArrayInvalid.PushBack(Vector3::ZERO);
// Set the initial value to non-zero, so we can test it does not change.
result = FaceCullingMode::FRONT_AND_BACK;
- returnValue = GetBitmaskEnumerationProperty< FaceCullingMode::Type >( propertyArrayInvalid, testTable, testTableCount, result );
+ returnValue = GetBitmaskEnumerationProperty<FaceCullingMode::Type>(propertyArrayInvalid, testTable, testTableCount, result);
// TEST: The return value when checking an array with an INTEGER and a Vector3 is "false" as the properties can not be successfully converted.
- DALI_TEST_CHECK( !returnValue );
+ DALI_TEST_CHECK(!returnValue);
// TEST: The result value when checking an array with an INTEGER and a Vector3 is unchanged.
- DALI_TEST_CHECK( result == FaceCullingMode::FRONT_AND_BACK );
+ DALI_TEST_CHECK(result == FaceCullingMode::FRONT_AND_BACK);
END_TEST;
}
{
const Scripting::StringEnum myTable[] =
{
- { "ONE", (1<<1) },
- { "TWO", (1<<2) },
- { "THREE", (1<<3) },
- { "FOUR", (1<<4) },
- { "FIVE", (1<<5) },
+ {"ONE", (1 << 1)},
+ {"TWO", (1 << 2)},
+ {"THREE", (1 << 3)},
+ {"FOUR", (1 << 4)},
+ {"FIVE", (1 << 5)},
};
- const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
- DALI_TEST_EQUALS( myTableCount, FindEnumIndex( "Foo", myTable, myTableCount ), TEST_LOCATION );
+ const unsigned int myTableCount = sizeof(myTable) / sizeof(myTable[0]);
+ DALI_TEST_EQUALS(myTableCount, FindEnumIndex("Foo", myTable, myTableCount), TEST_LOCATION);
END_TEST;
}
{
const Scripting::StringEnum myTable[] =
{
- { "ONE", (1<<1) },
- { "TWO", (1<<2) },
- { "THREE", (1<<3) },
- { "FOUR", (1<<4) },
- { "FIVE", (1<<5) },
+ {"ONE", (1 << 1)},
+ {"TWO", (1 << 2)},
+ {"THREE", (1 << 3)},
+ {"FOUR", (1 << 4)},
+ {"FIVE", (1 << 5)},
};
- const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+ const unsigned int myTableCount = sizeof(myTable) / sizeof(myTable[0]);
int integerEnum = 0;
- DALI_TEST_CHECK( EnumStringToInteger( "ONE", myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(EnumStringToInteger("ONE", myTable, myTableCount, integerEnum));
- DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
+ DALI_TEST_EQUALS(integerEnum, (1 << 1), TEST_LOCATION);
integerEnum = 0;
- DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("ONE,TWO", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1) | (1 << 2), TEST_LOCATION);
- DALI_TEST_CHECK( EnumStringToInteger( "ONE,,TWO", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("ONE,,TWO", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1) | (1 << 2), TEST_LOCATION);
- DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO,THREE", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("ONE,TWO,THREE", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1) | (1 << 2) | (1 << 3), TEST_LOCATION);
- DALI_TEST_CHECK( EnumStringToInteger( "ONE,TWO,THREE,FOUR,FIVE", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("ONE,TWO,THREE,FOUR,FIVE", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5), TEST_LOCATION);
- DALI_TEST_CHECK( EnumStringToInteger( "TWO,ONE", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("TWO,ONE", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1) | (1 << 2), TEST_LOCATION);
- DALI_TEST_CHECK( EnumStringToInteger( "TWO,ONE,FOUR,THREE,FIVE", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1) | (1<<2) | (1<<3) | (1<<4) | (1<<5), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("TWO,ONE,FOUR,THREE,FIVE", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1) | (1 << 2) | (1 << 3) | (1 << 4) | (1 << 5), TEST_LOCATION);
- DALI_TEST_CHECK( EnumStringToInteger( "ONE,SEVEN", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
-
- DALI_TEST_CHECK( EnumStringToInteger( "ONE,", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, (1<<1), TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("ONE,SEVEN", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1), TEST_LOCATION);
+ DALI_TEST_CHECK(EnumStringToInteger("ONE,", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, (1 << 1), TEST_LOCATION);
END_TEST;
}
int UtcDaliScriptingEnumStringToIntegerN(void)
{
const Scripting::StringEnum myTable[] =
- {
- { "ONE", 1 },
- { "TWO", 2 },
- { "THREE", 3 },
- { "FOUR", 4 },
- { "FIVE", 5 },
- };
- const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+ {
+ {"ONE", 1},
+ {"TWO", 2},
+ {"THREE", 3},
+ {"FOUR", 4},
+ {"FIVE", 5},
+ };
+ const unsigned int myTableCount = sizeof(myTable) / sizeof(myTable[0]);
int integerEnum = 0;
- DALI_TEST_CHECK( !EnumStringToInteger( "Foo", myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger("Foo", myTable, myTableCount, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( "", myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger("", myTable, myTableCount, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( ",", myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger(",", myTable, myTableCount, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( ",ONE,SEVEN", myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger(",ONE,SEVEN", myTable, myTableCount, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( ",", myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger(",", myTable, myTableCount, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( "ONE", myTable, 0, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger("ONE", myTable, 0, integerEnum));
- DALI_TEST_EQUALS( integerEnum, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(integerEnum, 0, TEST_LOCATION);
END_TEST;
}
int UtcDaliScriptingEnumStringToIntegerInvalidEnumP(void)
{
const Scripting::StringEnum myTable[] =
- {
- { "", 1 },
- { "", 2 },
- { "", 3 },
- };
+ {
+ {"", 1},
+ {"", 2},
+ {"", 3},
+ };
- const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+ const unsigned int myTableCount = sizeof(myTable) / sizeof(myTable[0]);
int integerEnum = 0;
- DALI_TEST_CHECK( EnumStringToInteger( "", myTable, myTableCount, integerEnum ) );
- DALI_TEST_EQUALS( integerEnum, 1, TEST_LOCATION );
+ DALI_TEST_CHECK(EnumStringToInteger("", myTable, myTableCount, integerEnum));
+ DALI_TEST_EQUALS(integerEnum, 1, TEST_LOCATION);
END_TEST;
}
int UtcDaliScriptingEnumStringToIntegerInvalidEnumN(void)
{
const Scripting::StringEnum myTable[] =
- {
- { "", 1 },
- { "", 1 },
- { "", 1 },
- };
+ {
+ {"", 1},
+ {"", 1},
+ {"", 1},
+ };
- const unsigned int myTableCount = sizeof( myTable ) / sizeof( myTable[0] );
+ const unsigned int myTableCount = sizeof(myTable) / sizeof(myTable[0]);
int integerEnum = 0;
- DALI_TEST_CHECK( !EnumStringToInteger( NULL, NULL, 0, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger(NULL, NULL, 0, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( "ONE", NULL, 0, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger("ONE", NULL, 0, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( NULL, myTable, 0, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger(NULL, myTable, 0, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( NULL, myTable, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger(NULL, myTable, myTableCount, integerEnum));
- DALI_TEST_CHECK( !EnumStringToInteger( "ONE", NULL, myTableCount, integerEnum ) );
+ DALI_TEST_CHECK(!EnumStringToInteger("ONE", NULL, myTableCount, integerEnum));
- DALI_TEST_EQUALS( integerEnum, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(integerEnum, 0, TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
#include <mesh-builder.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
static const char* VertexSource =
-"This is a custom vertex shader\n"
-"made on purpose to look nothing like a normal vertex shader inside dali\n";
+ "This is a custom vertex shader\n"
+ "made on purpose to look nothing like a normal vertex shader inside dali\n";
static const char* FragmentSource =
-"This is a custom fragment shader\n"
-"made on purpose to look nothing like a normal fragment shader inside dali\n";
-
+ "This is a custom fragment shader\n"
+ "made on purpose to look nothing like a normal fragment shader inside dali\n";
-void TestConstraintNoBlue( Vector4& current, const PropertyInputContainer& inputs )
+void TestConstraintNoBlue(Vector4& current, const PropertyInputContainer& inputs)
{
current.b = 0.0f;
}
-
-} // anon namespace
-
+} // namespace
int UtcDaliShaderMethodNew01(void)
{
TestApplication application;
- Shader shader = Shader::New( VertexSource, FragmentSource );
+ Shader shader = Shader::New(VertexSource, FragmentSource);
DALI_TEST_EQUALS((bool)shader, true, TEST_LOCATION);
END_TEST;
}
DALI_TEST_CHECK(shader1 == shader2);
- shader2 = Shader::New(VertexSource, FragmentSource);;
+ shader2 = Shader::New(VertexSource, FragmentSource);
+ ;
DALI_TEST_CHECK(!(shader1 == shader2));
TestApplication application;
Shader shader = Shader::New(VertexSource, FragmentSource);
- DALI_TEST_CHECK( shader );
- DALI_TEST_EQUALS( 1, shader.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(shader);
+ DALI_TEST_EQUALS(1, shader.GetBaseObject().ReferenceCount(), TEST_LOCATION);
// Register a custom property
- Vector2 vec( 1.0f, 2.0f );
- Property::Index customIndex = shader.RegisterProperty( "custom", vec );
- DALI_TEST_EQUALS( shader.GetProperty<Vector2>( customIndex ), vec, TEST_LOCATION );
+ Vector2 vec(1.0f, 2.0f);
+ Property::Index customIndex = shader.RegisterProperty("custom", vec);
+ DALI_TEST_EQUALS(shader.GetProperty<Vector2>(customIndex), vec, TEST_LOCATION);
- Shader move = std::move( shader );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetProperty<Vector2>( customIndex ), vec, TEST_LOCATION );
- DALI_TEST_CHECK( !shader );
+ Shader move = std::move(shader);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetProperty<Vector2>(customIndex), vec, TEST_LOCATION);
+ DALI_TEST_CHECK(!shader);
END_TEST;
}
TestApplication application;
Shader shader = Shader::New(VertexSource, FragmentSource);
- DALI_TEST_CHECK( shader );
- DALI_TEST_EQUALS( 1, shader.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(shader);
+ DALI_TEST_EQUALS(1, shader.GetBaseObject().ReferenceCount(), TEST_LOCATION);
// Register a custom property
- Vector2 vec( 1.0f, 2.0f );
- Property::Index customIndex = shader.RegisterProperty( "custom", vec );
- DALI_TEST_EQUALS( shader.GetProperty<Vector2>( customIndex ), vec, TEST_LOCATION );
+ Vector2 vec(1.0f, 2.0f);
+ Property::Index customIndex = shader.RegisterProperty("custom", vec);
+ DALI_TEST_EQUALS(shader.GetProperty<Vector2>(customIndex), vec, TEST_LOCATION);
Shader move;
- move = std::move( shader );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetProperty<Vector2>( customIndex ), vec, TEST_LOCATION );
- DALI_TEST_CHECK( !shader );
+ move = std::move(shader);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetProperty<Vector2>(customIndex), vec, TEST_LOCATION);
+ DALI_TEST_CHECK(!shader);
END_TEST;
}
Shader shader = Shader::New(VertexSource, FragmentSource);
BaseHandle handle(shader);
- Shader shader2 = Shader::DownCast(handle);
- DALI_TEST_EQUALS( (bool)shader2, true, TEST_LOCATION );
+ Shader shader2 = Shader::DownCast(handle);
+ DALI_TEST_EQUALS((bool)shader2, true, TEST_LOCATION);
END_TEST;
}
Handle handle = Handle::New(); // Create a custom object
Shader shader = Shader::DownCast(handle);
- DALI_TEST_EQUALS( (bool)shader, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)shader, false, TEST_LOCATION);
END_TEST;
}
int UtcDaliShaderDefaultProperties(void)
{
TestApplication application;
-// from shader-impl.cpp
-// DALI_PROPERTY( "program", MAP, true, false, false, Dali::Shader::Property::PROGRAM )
+ // from shader-impl.cpp
+ // DALI_PROPERTY( "program", MAP, true, false, false, Dali::Shader::Property::PROGRAM )
Shader shader = Shader::New(VertexSource, FragmentSource);
- DALI_TEST_EQUALS( shader.GetPropertyCount(), 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetPropertyCount(), 1, TEST_LOCATION);
- DALI_TEST_EQUALS( shader.GetPropertyName( Shader::Property::PROGRAM ), "program", TEST_LOCATION );
- DALI_TEST_EQUALS( shader.GetPropertyIndex( "program" ), (Property::Index)Shader::Property::PROGRAM, TEST_LOCATION );
- DALI_TEST_EQUALS( shader.GetPropertyType( Shader::Property::PROGRAM ), Property::MAP, TEST_LOCATION );
- DALI_TEST_EQUALS( shader.IsPropertyWritable( Shader::Property::PROGRAM ), true, TEST_LOCATION );
- DALI_TEST_EQUALS( shader.IsPropertyAnimatable( Shader::Property::PROGRAM ), false, TEST_LOCATION );
- DALI_TEST_EQUALS( shader.IsPropertyAConstraintInput( Shader::Property::PROGRAM ), false, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetPropertyName(Shader::Property::PROGRAM), "program", TEST_LOCATION);
+ DALI_TEST_EQUALS(shader.GetPropertyIndex("program"), (Property::Index)Shader::Property::PROGRAM, TEST_LOCATION);
+ DALI_TEST_EQUALS(shader.GetPropertyType(Shader::Property::PROGRAM), Property::MAP, TEST_LOCATION);
+ DALI_TEST_EQUALS(shader.IsPropertyWritable(Shader::Property::PROGRAM), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(shader.IsPropertyAnimatable(Shader::Property::PROGRAM), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(shader.IsPropertyAConstraintInput(Shader::Property::PROGRAM), false, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a non-uniform shader property can be constrained");
- Shader shader = Shader::New(VertexSource, FragmentSource);
+ Shader shader = Shader::New(VertexSource, FragmentSource);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = shader.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = shader.RegisterProperty("uFadeColor", initialColor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( shader.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION);
// Apply constraint
- Constraint constraint = Constraint::New<Vector4>( shader, colorIndex, TestConstraintNoBlue );
+ Constraint constraint = Constraint::New<Vector4>(shader, colorIndex, TestConstraintNoBlue);
constraint.Apply();
application.SendNotification();
application.Render(0);
// Expect no blue component in either buffer - yellow
- DALI_TEST_EQUALS( shader.GetCurrentProperty< Vector4 >( colorIndex ), Color::YELLOW, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetCurrentProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION);
application.Render(0);
- DALI_TEST_EQUALS( shader.GetCurrentProperty< Vector4 >( colorIndex ), Color::YELLOW, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetCurrentProperty<Vector4>(colorIndex), Color::YELLOW, TEST_LOCATION);
shader.RemoveConstraints();
- shader.SetProperty(colorIndex, Color::WHITE );
+ shader.SetProperty(colorIndex, Color::WHITE);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( shader.GetCurrentProperty< Vector4 >( colorIndex ), Color::WHITE, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetCurrentProperty<Vector4>(colorIndex), Color::WHITE, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a uniform map shader property can be constrained");
- Shader shader = Shader::New(VertexSource, FragmentSource);
+ Shader shader = Shader::New(VertexSource, FragmentSource);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = shader.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = shader.RegisterProperty("uFadeColor", initialColor);
TestGlAbstraction& gl = application.GetGlAbstraction();
application.Render(0);
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, initialColor, TEST_LOCATION);
// Apply constraint
- Constraint constraint = Constraint::New<Vector4>( shader, colorIndex, TestConstraintNoBlue );
+ Constraint constraint = Constraint::New<Vector4>(shader, colorIndex, TestConstraintNoBlue);
constraint.Apply();
application.SendNotification();
application.Render(0);
- // Expect no blue component in either buffer - yellow
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
+ // Expect no blue component in either buffer - yellow
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::YELLOW, TEST_LOCATION);
application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::YELLOW, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::YELLOW, TEST_LOCATION);
shader.RemoveConstraints();
- shader.SetProperty(colorIndex, Color::WHITE );
+ shader.SetProperty(colorIndex, Color::WHITE);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::WHITE, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a non-uniform shader property can be animated");
- Shader shader = Shader::New(VertexSource, FragmentSource);
+ Shader shader = Shader::New(VertexSource, FragmentSource);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = shader.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = shader.RegisterProperty("uFadeColor", initialColor);
application.SendNotification();
application.Render(0);
- DALI_TEST_EQUALS( shader.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetProperty<Vector4>(colorIndex), initialColor, TEST_LOCATION);
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, initialColor);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( shader, colorIndex ), keyFrames );
+ animation.AnimateBetween(Property(shader, colorIndex), keyFrames);
animation.Play();
application.SendNotification();
application.Render(500);
- DALI_TEST_EQUALS( shader.GetCurrentProperty< Vector4 >( colorIndex ), Color::WHITE * 0.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetCurrentProperty<Vector4>(colorIndex), Color::WHITE * 0.5f, TEST_LOCATION);
application.Render(500);
- DALI_TEST_EQUALS( shader.GetCurrentProperty< Vector4 >( colorIndex ), Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetCurrentProperty<Vector4>(colorIndex), Color::TRANSPARENT, TEST_LOCATION);
END_TEST;
}
tet_infoline("Test that a uniform map shader property can be animated");
- Shader shader = Shader::New(VertexSource, FragmentSource);
+ Shader shader = Shader::New(VertexSource, FragmentSource);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
+ Renderer renderer = Renderer::New(geometry, shader);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
application.GetScene().Add(actor);
application.SendNotification();
application.Render(0);
- Vector4 initialColor = Color::WHITE;
- Property::Index colorIndex = shader.RegisterProperty( "uFadeColor", initialColor );
+ Vector4 initialColor = Color::WHITE;
+ Property::Index colorIndex = shader.RegisterProperty("uFadeColor", initialColor);
TestGlAbstraction& gl = application.GetGlAbstraction();
application.Render(0);
Vector4 actualValue(Vector4::ZERO);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, initialColor, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, initialColor, TEST_LOCATION);
- Animation animation = Animation::New(1.0f);
+ Animation animation = Animation::New(1.0f);
KeyFrames keyFrames = KeyFrames::New();
keyFrames.Add(0.0f, initialColor);
keyFrames.Add(1.0f, Color::TRANSPARENT);
- animation.AnimateBetween( Property( shader, colorIndex ), keyFrames );
+ animation.AnimateBetween(Property(shader, colorIndex), keyFrames);
animation.Play();
application.SendNotification();
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::WHITE * 0.5f, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::WHITE * 0.5f, TEST_LOCATION);
application.Render(500);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::TRANSPARENT, TEST_LOCATION);
// change shader program
Property::Map map;
- map["vertex"] = VertexSource;
+ map["vertex"] = VertexSource;
map["fragment"] = FragmentSource;
- map["hints"] = "MODIFIES_GEOMETRY";
- shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
+ map["hints"] = "MODIFIES_GEOMETRY";
+ shader.SetProperty(Shader::Property::PROGRAM, Property::Value(map));
application.SendNotification();
application.Render(100);
// register another custom property as well
- Property::Index customIndex = shader.RegisterProperty( "uCustom", Vector3(1,2,3) );
- DALI_TEST_EQUALS( shader.GetProperty<Vector3>( customIndex ), Vector3(1,2,3), TEST_LOCATION );
+ Property::Index customIndex = shader.RegisterProperty("uCustom", Vector3(1, 2, 3));
+ DALI_TEST_EQUALS(shader.GetProperty<Vector3>(customIndex), Vector3(1, 2, 3), TEST_LOCATION);
application.SendNotification();
application.Render(100);
- DALI_TEST_CHECK( gl.GetUniformValue<Vector4>( "uFadeColor", actualValue ) );
- DALI_TEST_EQUALS( actualValue, Color::TRANSPARENT, TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector4>("uFadeColor", actualValue));
+ DALI_TEST_EQUALS(actualValue, Color::TRANSPARENT, TEST_LOCATION);
Vector3 customValue;
- DALI_TEST_CHECK( gl.GetUniformValue<Vector3>( "uCustom", customValue ) );
- DALI_TEST_EQUALS( customValue, Vector3(1,2,3), TEST_LOCATION );
+ DALI_TEST_CHECK(gl.GetUniformValue<Vector3>("uCustom", customValue));
+ DALI_TEST_EQUALS(customValue, Vector3(1, 2, 3), TEST_LOCATION);
END_TEST;
}
tet_infoline("Test get/set progam property");
- Shader shader = Shader::New("", "");
+ Shader shader = Shader::New("", "");
std::string hintSet = "MODIFIES_GEOMETRY";
Property::Map map;
- map["vertex"] = VertexSource;
+ map["vertex"] = VertexSource;
map["fragment"] = FragmentSource;
- map["hints"] = hintSet;
+ map["hints"] = hintSet;
- shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
+ shader.SetProperty(Shader::Property::PROGRAM, Property::Value(map));
// register a custom property as well
- Property::Index customIndex = shader.RegisterProperty( "custom", Vector3(1,2,3) );
- DALI_TEST_EQUALS( shader.GetProperty<Vector3>( customIndex ), Vector3(1,2,3), TEST_LOCATION );
+ Property::Index customIndex = shader.RegisterProperty("custom", Vector3(1, 2, 3));
+ DALI_TEST_EQUALS(shader.GetProperty<Vector3>(customIndex), Vector3(1, 2, 3), TEST_LOCATION);
Property::Value value = shader.GetProperty(Shader::Property::PROGRAM);
- DALI_TEST_CHECK( value.GetType() == Property::MAP);
+ DALI_TEST_CHECK(value.GetType() == Property::MAP);
const Property::Map* outMap = value.GetMap();
std::string v = (*outMap)["vertex"].Get<std::string>();
std::string f = (*outMap)["fragment"].Get<std::string>();
std::string h = (*outMap)["hints"].Get<std::string>();
- DALI_TEST_CHECK( v == VertexSource );
- DALI_TEST_CHECK( f == FragmentSource );
- DALI_TEST_CHECK( h == hintSet );
+ DALI_TEST_CHECK(v == VertexSource);
+ DALI_TEST_CHECK(f == FragmentSource);
+ DALI_TEST_CHECK(h == hintSet);
- value = shader.GetCurrentProperty( Shader::Property::PROGRAM );
- DALI_TEST_CHECK( value.GetType() == Property::MAP);
+ value = shader.GetCurrentProperty(Shader::Property::PROGRAM);
+ DALI_TEST_CHECK(value.GetType() == Property::MAP);
outMap = value.GetMap();
// check that changing the shader did not cause us to loose custom property
- DALI_TEST_EQUALS( shader.GetProperty<Vector3>( customIndex ), Vector3(1,2,3), TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetProperty<Vector3>(customIndex), Vector3(1, 2, 3), TEST_LOCATION);
using Dali::Animation;
- Animation animation = Animation::New( 0.1f );
- animation.AnimateTo( Property( shader, customIndex ), Vector3(4,5,6) );
+ Animation animation = Animation::New(0.1f);
+ animation.AnimateTo(Property(shader, customIndex), Vector3(4, 5, 6));
animation.Play();
application.SendNotification();
application.Render(100);
- DALI_TEST_EQUALS( shader.GetProperty<Vector3>( customIndex ), Vector3(4,5,6), TEST_LOCATION );
+ DALI_TEST_EQUALS(shader.GetProperty<Vector3>(customIndex), Vector3(4, 5, 6), TEST_LOCATION);
v = (*outMap)["vertex"].Get<std::string>();
f = (*outMap)["fragment"].Get<std::string>();
h = (*outMap)["hints"].Get<std::string>();
- DALI_TEST_CHECK( v == VertexSource );
- DALI_TEST_CHECK( f == FragmentSource );
- DALI_TEST_CHECK( h == hintSet );
+ DALI_TEST_CHECK(v == VertexSource);
+ DALI_TEST_CHECK(f == FragmentSource);
+ DALI_TEST_CHECK(h == hintSet);
std::string hintGot;
- hintSet = "OUTPUT_IS_TRANSPARENT,MODIFIES_GEOMETRY";
+ hintSet = "OUTPUT_IS_TRANSPARENT,MODIFIES_GEOMETRY";
map["hints"] = hintSet;
- shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
- value = shader.GetProperty(Shader::Property::PROGRAM);
+ shader.SetProperty(Shader::Property::PROGRAM, Property::Value(map));
+ value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
- DALI_TEST_CHECK( hintGot == hintSet );
+ DALI_TEST_CHECK(hintGot == hintSet);
- hintSet = "OUTPUT_IS_TRANSPARENT";
+ hintSet = "OUTPUT_IS_TRANSPARENT";
map["hints"] = hintSet;
- shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
- value = shader.GetProperty(Shader::Property::PROGRAM);
+ shader.SetProperty(Shader::Property::PROGRAM, Property::Value(map));
+ value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
- DALI_TEST_CHECK( hintGot == hintSet );
+ DALI_TEST_CHECK(hintGot == hintSet);
- hintSet = "NONE";
+ hintSet = "NONE";
map["hints"] = hintSet;
- shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
- value = shader.GetProperty(Shader::Property::PROGRAM);
+ shader.SetProperty(Shader::Property::PROGRAM, Property::Value(map));
+ value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
- DALI_TEST_CHECK( hintGot == hintSet );
+ DALI_TEST_CHECK(hintGot == hintSet);
- hintSet = "";
+ hintSet = "";
map["hints"] = hintSet;
- shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
- value = shader.GetProperty(Shader::Property::PROGRAM);
+ shader.SetProperty(Shader::Property::PROGRAM, Property::Value(map));
+ value = shader.GetProperty(Shader::Property::PROGRAM);
hintGot = (*value.GetMap())["hints"].Get<std::string>();
- DALI_TEST_CHECK( hintGot == "NONE" );
+ DALI_TEST_CHECK(hintGot == "NONE");
END_TEST;
}
*/
// EXTERNAL INCLUDES
-#include <iostream>
#include <stdlib.h>
+#include <iostream>
+
// INTERNAL INCLUDES
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/signals/signal-delegate.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/signals/signal-delegate.h>
+#include <dali/public-api/dali-core.h>
using namespace Dali;
-
void utc_dali_signal_delegate_startup(void)
{
test_return_value = TET_UNDEF;
class SignalDelegateTestClass : public Dali::ConnectionTracker
{
public:
-
- SignalDelegateTestClass( Actor connectActor, std::string connectSignal )
+ SignalDelegateTestClass(Actor connectActor, std::string connectSignal)
{
- mSignalDelegate = new SignalDelegate( connectActor, connectSignal );
+ mSignalDelegate = new SignalDelegate(connectActor, connectSignal);
}
void ConnectToInternalMember()
{
- mSignalDelegate->Connect( this, &SignalDelegateTestClass::SignalHandlerMemberFunction );
+ mSignalDelegate->Connect(this, &SignalDelegateTestClass::SignalHandlerMemberFunction);
}
bool IsConnected()
}
private:
-
void SignalHandlerMemberFunction()
{
- tet_infoline( "Got signal in member function\n" );
+ tet_infoline("Got signal in member function\n");
gSignalReceived = true;
}
}
};
-
// Test cases:
int UtcDaliSignalDelegateIsConnectedP(void)
{
TestApplication application;
- tet_infoline( " UtcDaliSignalDelegateIsConnectedP" );
+ tet_infoline(" UtcDaliSignalDelegateIsConnectedP");
// Set up an actor with a signal to connect to.
- Actor connectActor = Actor::New();
+ Actor connectActor = Actor::New();
std::string connectSignal = "onScene";
// Create the test class (this will create the delegate, but not connect to it yet.
- SignalDelegateTestClass testObject( connectActor, connectSignal );
+ SignalDelegateTestClass testObject(connectActor, connectSignal);
// Tell the test class to connect the delegate to it's internal member.
// Note: It is at this point that the delegate internally makes the connection.
testObject.ConnectToInternalMember();
- DALI_TEST_CHECK( testObject.IsConnected() );
+ DALI_TEST_CHECK(testObject.IsConnected());
END_TEST;
}
int UtcDaliSignalDelegateIsConnectedN(void)
{
TestApplication application;
- tet_infoline( " UtcDaliSignalDelegateIsConnectedN" );
+ tet_infoline(" UtcDaliSignalDelegateIsConnectedN");
// Set up an actor with a signal to connect to.
- Actor connectActor = Actor::New();
+ Actor connectActor = Actor::New();
std::string connectSignal = "onScene";
// Create the test class (this will create the delegate, but not connect to it yet.
- SignalDelegateTestClass testObject( connectActor, connectSignal );
+ SignalDelegateTestClass testObject(connectActor, connectSignal);
- DALI_TEST_CHECK( !testObject.IsConnected() );
+ DALI_TEST_CHECK(!testObject.IsConnected());
END_TEST;
}
int UtcDaliSignalDelegateConnectToMemberP(void)
{
TestApplication application;
- tet_infoline( " UtcDaliSignalDelegateConnectToMemberP" );
+ tet_infoline(" UtcDaliSignalDelegateConnectToMemberP");
// Set up an actor with a signal to connect to.
- Actor connectActor = Actor::New();
+ Actor connectActor = Actor::New();
std::string connectSignal = "onScene";
gSignalReceived = false;
// Create the test class (this will create the delegate, but not connect to it yet.
- SignalDelegateTestClass testObject( connectActor, connectSignal );
+ SignalDelegateTestClass testObject(connectActor, connectSignal);
// Tell the test class to connect the delegate to it's internal member.
// Note: It is at this point that the delegate internally makes the connection.
// Add the actor to the scene to trigger it's "onScene" signal.
// If the delegate connected correctly, this will call the member
// function in the test object and set a global flag.
- application.GetScene().Add( connectActor );
+ application.GetScene().Add(connectActor);
// Check the global flag to confirm the signal was received.
- DALI_TEST_CHECK( gSignalReceived );
+ DALI_TEST_CHECK(gSignalReceived);
END_TEST;
}
int UtcDaliSignalDelegateConnectToMemberN(void)
{
TestApplication application;
- tet_infoline( " UtcDaliSignalDelegateConnectToMemberN" );
+ tet_infoline(" UtcDaliSignalDelegateConnectToMemberN");
// Set up an actor with a signal to connect to.
- Actor connectActor = Actor::New();
+ Actor connectActor = Actor::New();
std::string connectSignal = "onScene";
gSignalReceived = false;
// Create the test class (this will create the delegate, but not connect to it yet.
- SignalDelegateTestClass testObject( connectActor, connectSignal );
+ SignalDelegateTestClass testObject(connectActor, connectSignal);
// Tell the test class to connect the delegate to it's internal member.
// Note: It is at this point that the delegate internally makes the connection.
testObject.ConnectToInternalMember();
// Check the global flag to confirm the signal was not received.
- DALI_TEST_CHECK( !gSignalReceived );
+ DALI_TEST_CHECK(!gSignalReceived);
END_TEST;
}
int UtcDaliSignalDelegateConnectToFunctorP(void)
{
TestApplication application;
- tet_infoline( " UtcDaliSignalDelegateConnectToFunctorP" );
+ tet_infoline(" UtcDaliSignalDelegateConnectToFunctorP");
// Set up an actor with a signal to connect to.
- Actor connectActor = Actor::New();
+ Actor connectActor = Actor::New();
std::string connectSignal = "onScene";
// Initialise the signal delegate with the actor to connect to and it's signal.
- SignalDelegate signalDelegate( connectActor, connectSignal );
+ SignalDelegate signalDelegate(connectActor, connectSignal);
// We need a connection tracker object to associated with the connection.
// This could normally be "this", but since we are not within a class, we pass
TestConnectionTrackerObject* testTracker = new TestConnectionTrackerObject();
// Check the signal delegate currently has no connection.
- DALI_TEST_CHECK( !signalDelegate.IsConnected() );
+ DALI_TEST_CHECK(!signalDelegate.IsConnected());
// Tell the signal delegate to connect to the given functor (via a functor delegate).
// Note: It is at this point that the delegate internally makes the connection.
- signalDelegate.Connect( testTracker, FunctorDelegate::New( SignalDelegateTestFunctor() ) );
+ signalDelegate.Connect(testTracker, FunctorDelegate::New(SignalDelegateTestFunctor()));
// Check the signal delegate has made the connection.
- DALI_TEST_CHECK( signalDelegate.IsConnected() );
+ DALI_TEST_CHECK(signalDelegate.IsConnected());
// Add the actor to the scene to trigger it's "onScene" signal.
// If the delegate connected correctly, this will call the () operator of our
// passed-in functor, the functor will in turn set a global flag.
- application.GetScene().Add( connectActor );
+ application.GetScene().Add(connectActor);
// Check the global flag to confirm the signal was received.
- DALI_TEST_CHECK( gSignalReceived );
+ DALI_TEST_CHECK(gSignalReceived);
END_TEST;
}
int UtcDaliSignalDelegateConnectToFunctorN(void)
{
TestApplication application;
- tet_infoline( " UtcDaliSignalDelegateConnectToFunctorN" );
+ tet_infoline(" UtcDaliSignalDelegateConnectToFunctorN");
// Set up an actor with a signal to connect to.
- Actor connectActor = Actor::New();
+ Actor connectActor = Actor::New();
std::string connectSignal = "onScene";
// Initialise the signal delegate with the actor to connect to and it's signal.
- SignalDelegate signalDelegate( connectActor, connectSignal );
+ SignalDelegate signalDelegate(connectActor, connectSignal);
// We need a connection tracker object to associated with the connection.
// This could normally be "this", but since we are not within a class, we pass
TestConnectionTrackerObject* testTracker = new TestConnectionTrackerObject();
// Check the signal delegate currently has no connection.
- DALI_TEST_CHECK( !signalDelegate.IsConnected() );
+ DALI_TEST_CHECK(!signalDelegate.IsConnected());
// Tell the signal delegate to connect to the given functor (via a functor delegate).
// Note: It is at this point that the delegate internally makes the connection.
- signalDelegate.Connect( testTracker, FunctorDelegate::New( SignalDelegateTestFunctor() ) );
+ signalDelegate.Connect(testTracker, FunctorDelegate::New(SignalDelegateTestFunctor()));
// Check the signal delegate has made the connection.
- DALI_TEST_CHECK( signalDelegate.IsConnected() );
+ DALI_TEST_CHECK(signalDelegate.IsConnected());
// Check the global flag to confirm the signal was received.
- DALI_TEST_CHECK( !gSignalReceived );
+ DALI_TEST_CHECK(!gSignalReceived);
END_TEST;
}
*/
// EXTERNAL INCLUDES
-#include <iostream>
#include <stdlib.h>
+#include <iostream>
+
// INTERNAL INCLUDES
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+
#include "signal-helper.h"
using namespace Dali;
test_return_value = TET_PASS;
}
-namespace {
-
-
-bool wasStaticVoidCallbackVoidCalled = false;
-bool wasStaticFloatCallbackVoidCalled = false;
-bool wasStaticVoidCallbackIntValueCalled = false;
-int staticIntValue = 0;
-bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
-float staticFloatValue1 = 0.0f;
-float staticFloatValue2 = 0.0f;
+namespace
+{
+bool wasStaticVoidCallbackVoidCalled = false;
+bool wasStaticFloatCallbackVoidCalled = false;
+bool wasStaticVoidCallbackIntValueCalled = false;
+int staticIntValue = 0;
+bool wasStaticFloatCallbackFloatValueFloatValueCalled = false;
+float staticFloatValue1 = 0.0f;
+float staticFloatValue2 = 0.0f;
void StaticVoidCallbackVoid()
{
return 7.0f;
}
-void StaticVoidCallbackIntValue( int value )
+void StaticVoidCallbackIntValue(int value)
{
wasStaticVoidCallbackIntValueCalled = true;
- staticIntValue = value;
+ staticIntValue = value;
}
-float StaticFloatCallbackFloatValueFloatValue( float value1, float value2 )
+float StaticFloatCallbackFloatValueFloatValue(float value1, float value2)
{
wasStaticFloatCallbackFloatValueFloatValueCalled = true;
- staticFloatValue1 = value1;
- staticFloatValue2 = value2;
+ staticFloatValue1 = value1;
+ staticFloatValue2 = value2;
return value1 + value2;
}
-} // anon namespace
-
-
+} // namespace
/*******************************************
*
{
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
}
// Test that Empty() is true, when a slot has connected and disconnected
{
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( signal.Empty() );
+ TestSlotHandler handler;
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ signal.Disconnect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(signal.Empty());
}
END_TEST;
// Test that Empty() is false after signal connection
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ TestSlotHandler handler;
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
END_TEST;
}
TestApplication application; // Create core for debug logging
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( signal.GetConnectionCount() == 1 );
+ TestSlotHandler handler;
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(signal.GetConnectionCount() == 1);
TestSlotHandler handler2;
- signal.Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( signal.GetConnectionCount() == 2 );
+ signal.Connect(&handler2, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(signal.GetConnectionCount() == 2);
END_TEST;
}
int UtcDaliSignalGetConnectionCountN(void)
{
- TestApplication application; // Create core for debug logging
+ TestApplication application; // Create core for debug logging
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.GetConnectionCount() == 0 );
+ DALI_TEST_CHECK(signal.GetConnectionCount() == 0);
END_TEST;
}
// test static function: void Connect( void (*func)() )
TestSignals::VoidRetNoParamSignal signal;
- signal.Connect( StaticVoidCallbackVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
-
+ signal.Connect(StaticVoidCallbackVoid);
+ DALI_TEST_CHECK(!signal.Empty());
END_TEST;
}
TestApplication application; // Create core for debug logging
TestSignals::VoidRetNoParamSignal signal;
- signal.Connect( NULL );
+ signal.Connect(NULL);
try
{
signal.Emit();
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
// Tests that a negative test of an assertion succeeds
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_PASS);
}
END_TEST;
}
-
int UtcDaliSignalConnectP02(void)
{
TestApplication application; // Create core for debug logging
// test member function: Connect( X* obj, void (X::*func)() ))
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ TestSlotHandler handler;
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_CHECK( handler.mHandled == true );
+ DALI_TEST_CHECK(handler.mHandled == true);
END_TEST;
}
try
{
// test member function: Connect( X* obj, void (X::*func)() )) with NULL object
- signal.Connect( static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid );
+ signal.Connect(static_cast<TestSlotHandler*>(NULL), &TestSlotHandler::VoidSlotVoid);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
// Tests that a negative test of an assertion succeeds
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
tet_result(TET_PASS);
}
END_TEST;
}
-
int UtcDaliSignalConnectP03(void)
{
TestApplication application; // Create core for debug logging
// test slot delegate: Connect( SlotDelegate<X>& delegate, void (X::*func)() )
TestSignals::VoidRetNoParamSignal signal;
- TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ TestSlotDelegateHandler handler;
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_CHECK( handler.mHandled == true );
+ DALI_TEST_CHECK(handler.mHandled == true);
END_TEST;
}
{
TestApplication application; // Create core for debug logging
// the delegate is passed by reference, so you can't pass null.
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
END_TEST;
}
TestApplication application; // Create core for debug logging
// test function object: Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
- TestSlotHandler handler;
+ TestSlotHandler handler;
TestSignals::VoidRetNoParamSignal signal;
- bool functorCalled(false);
- TestFunctor functor( functorCalled );
- signal.Connect( &handler, functor );
- DALI_TEST_CHECK( ! signal.Empty() );
+ bool functorCalled(false);
+ TestFunctor functor(functorCalled);
+ signal.Connect(&handler, functor);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_CHECK( functorCalled == true );
+ DALI_TEST_CHECK(functorCalled == true);
END_TEST;
}
{
// for negative test we try to connect a null connection tracker to the signal
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler *nullHandler( NULL );
+ TestSlotHandler* nullHandler(NULL);
try
{
- signal.Connect( nullHandler , &TestSlotHandler::VoidSlotVoid );
+ signal.Connect(nullHandler, &TestSlotHandler::VoidSlotVoid);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
// Tests that a negative test of an assertion succeeds
- DALI_TEST_PRINT_ASSERT( e );
- tet_result( TET_PASS );
+ DALI_TEST_PRINT_ASSERT(e);
+ tet_result(TET_PASS);
}
END_TEST;
-
}
int UtcDaliSignalConnectP05(void)
// test function object using FunctorDelegate.
// :Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
{
- TestSlotHandler handler;
+ TestSlotHandler handler;
TestSignals::VoidRetNoParamSignal signal;
- bool functorDelegateCalled(false);
- signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
- DALI_TEST_CHECK( ! signal.Empty() );
+ bool functorDelegateCalled(false);
+ signal.Connect(&handler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_CHECK( functorDelegateCalled == true );
+ DALI_TEST_CHECK(functorDelegateCalled == true);
}
{
- TestSlotHandler handler;
+ TestSlotHandler handler;
TestSignals::VoidRet1ValueParamSignal signal;
- bool functorDelegateCalled(false);
- signal.Connect( &handler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
- DALI_TEST_CHECK( ! signal.Empty() );
+ bool functorDelegateCalled(false);
+ signal.Connect(&handler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit(1);
}
END_TEST;
// for negative test we try to connect a null connection tracker to the signal
// :Connect( ConnectionTrackerInterface == NULL, FunctorDelegate* delegate )
- TestSlotHandler *nullHandler( NULL );
+ TestSlotHandler* nullHandler(NULL);
TestSignals::VoidRetNoParamSignal signal;
- bool functorDelegateCalled(false);
+ bool functorDelegateCalled(false);
try
{
- signal.Connect( nullHandler, FunctorDelegate::New( VoidFunctorVoid(functorDelegateCalled) ));
+ signal.Connect(nullHandler, FunctorDelegate::New(VoidFunctorVoid(functorDelegateCalled)));
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- tet_result( TET_PASS );
+ DALI_TEST_PRINT_ASSERT(e);
+ tet_result(TET_PASS);
}
END_TEST;
}
-
/**
* there 3 different disconnect functions
* we go through them here in order of definition in dali-signal.h
// test static function: Disconnect( void (*func)( Arg0 arg0 ) )
TestSignals::VoidRetNoParamSignal signal;
- signal.Connect( StaticVoidCallbackVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- signal.Disconnect( StaticVoidCallbackVoid );
- DALI_TEST_CHECK( signal.Empty() );
+ signal.Connect(StaticVoidCallbackVoid);
+ DALI_TEST_CHECK(!signal.Empty());
+ signal.Disconnect(StaticVoidCallbackVoid);
+ DALI_TEST_CHECK(signal.Empty());
END_TEST;
-
- }
+}
int UtcDaliSignalDisconnectN01(void)
{
TestApplication application; // Create core for debug logging
// 1. Disconnect using the function
TestSignals::VoidRetNoParamSignal signal;
- signal.Connect( StaticVoidCallbackVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(StaticVoidCallbackVoid);
+ DALI_TEST_CHECK(!signal.Empty());
- signal.Disconnect( AlternativeVoidCallbackVoid );
+ signal.Disconnect(AlternativeVoidCallbackVoid);
- DALI_TEST_CHECK( ! signal.Empty() );
+ DALI_TEST_CHECK(!signal.Empty());
END_TEST;
}
// test member function: Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- signal.Disconnect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( signal.Empty() );
+ TestSlotHandler handler;
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
+ signal.Disconnect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(signal.Empty());
END_TEST;
-
}
int UtcDaliSignalDisconnectN02(void)
{
// 1. Disconnect using a null connection tracker
TestSignals::VoidRetNoParamSignal signal;
- TestSlotHandler handler;
+ TestSlotHandler handler;
- signal.Connect( &handler , &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( !signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
try
{
- TestSlotHandler* nullHandler( NULL );
- signal.Disconnect( nullHandler , &TestSlotHandler::VoidSlotVoid );
+ TestSlotHandler* nullHandler(NULL);
+ signal.Disconnect(nullHandler, &TestSlotHandler::VoidSlotVoid);
}
catch(Dali::DaliException& e)
{
// Tests that a negative test of an assertion succeeds
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_CHECK( !signal.Empty() );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_CHECK(!signal.Empty());
}
END_TEST;
}
// test slot delegate: Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
TestSignals::VoidRetNoParamSignal signal;
- TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- signal.Disconnect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
- DALI_TEST_CHECK( signal.Empty() );
+ TestSlotDelegateHandler handler;
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
+ signal.Disconnect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(signal.Empty());
END_TEST;
}
{
TestApplication application; // Create core for debug logging
- // try to disconnect from the wrong signal
+ // try to disconnect from the wrong signal
TestSignals::VoidRetNoParamSignal signal;
- TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
+ TestSlotDelegateHandler handler;
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
// use different signal
- signal.Disconnect( handler.mSlotDelegate , &TestSlotDelegateHandler::AlternativeVoidSlotVoid );
+ signal.Disconnect(handler.mSlotDelegate, &TestSlotDelegateHandler::AlternativeVoidSlotVoid);
- DALI_TEST_CHECK( !signal.Empty() );
+ DALI_TEST_CHECK(!signal.Empty());
END_TEST;
-
}
/*******************************************
{
TestSignals::VoidRetNoParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
signal.Emit();
{
TestSignals::VoidRet1ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- signal.Emit( 10 );
+ signal.Emit(10);
}
{
TestSignals::VoidRet1RefParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntRef );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotIntRef);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- int temp( 5 );
- signal.Emit( temp );
+ int temp(5);
+ signal.Emit(temp);
}
{
TestSignals::VoidRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::VoidSlotIntValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::VoidSlotIntValueIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- signal.Emit( 1, 2 );
+ signal.Emit(1, 2);
}
{
TestSignals::BoolRet1ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::BoolSlotFloatValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- bool blah = signal.Emit( 1.0f );
- DALI_TEST_CHECK( ! blah );
+ bool blah = signal.Emit(1.0f);
+ DALI_TEST_CHECK(!blah);
}
{
TestSignals::BoolRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::BoolSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::BoolSlotFloatValueIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- bool blah = signal.Emit( 1.0f, 2 );
- DALI_TEST_CHECK( ! blah );
+ bool blah = signal.Emit(1.0f, 2);
+ DALI_TEST_CHECK(!blah);
}
{
TestSignals::IntRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::IntSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::IntSlotFloatValueIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- int blah = signal.Emit( 10.0f, 100 );
- DALI_TEST_CHECK( 0 == blah );
+ int blah = signal.Emit(10.0f, 100);
+ DALI_TEST_CHECK(0 == blah);
}
{
TestSignals::FloatRet0ParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
- signal.Connect( &handler, &TestSlotHandler::FloatSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&handler, &TestSlotHandler::FloatSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
float blah = signal.Emit();
- DALI_TEST_CHECK( 0.0f == blah );
+ DALI_TEST_CHECK(0.0f == blah);
}
{
TestSignals::FloatRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotHandler handler;
signal.Connect(&handler, &TestSlotHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_CHECK( ! signal.Empty() );
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- float blah = signal.Emit( 3.0f, 4.0f );
- DALI_TEST_CHECK( 0.0f == blah );
+ float blah = signal.Emit(3.0f, 4.0f);
+ DALI_TEST_CHECK(0.0f == blah);
}
END_TEST;
}
{
TestSlotHandler handlers;
signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
// Test double emission
handlers.mHandled = false;
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
int x = 7;
signals.EmitVoidSignalIntRef(x);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignal1IntValue(5);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignal2IntValue(6, 7);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
// repeat with opposite return value
handlers.mBoolReturn = false;
- handlers.mHandled = false;
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
+ handlers.mHandled = false;
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mIntReturn = 27;
- int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
- DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
+ int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
+ DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
- float f = signals.EmitFloat0Signal();
- DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ float f = signals.EmitFloat0Signal();
+ DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
- float f = signals.EmitFloat2VSignal(5, 33.0f);
- DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
+ float f = signals.EmitFloat2VSignal(5, 33.0f);
+ DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.VoidSignalFloatValue3().Connect(&handlers, &TestSlotHandler::VoidSlotFloatValue3);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotHandler handlers;
signals.SignalFloat3Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValue3);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
- float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
- DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
+ float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
+ DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
END_TEST;
int UtcDaliSignalConnectAndEmit02P(void)
{
// testing connection of static functions
- TestSignals signals;
+ TestSignals signals;
StaticFunctionHandlers handlers;
// void ( void )
- signals.SignalVoidNone().Connect( &StaticFunctionHandlers::VoidSlotVoid );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.SignalVoidNone().Connect(&StaticFunctionHandlers::VoidSlotVoid);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// void ( p1 )
handlers.Reset();
- signals.SignalVoid1Value().Connect( &StaticFunctionHandlers::VoidSlot1Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
- signals.EmitVoidSignal1IntValue( 1 );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+ signals.SignalVoid1Value().Connect(&StaticFunctionHandlers::VoidSlot1Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
+ signals.EmitVoidSignal1IntValue(1);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// void ( p1, p2 )
handlers.Reset();
- signals.SignalVoid2Value().Connect( &StaticFunctionHandlers::VoidSlot2Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
- signals.EmitVoidSignal2IntValue( 1, 2 );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
-
+ signals.SignalVoid2Value().Connect(&StaticFunctionHandlers::VoidSlot2Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
+ signals.EmitVoidSignal2IntValue(1, 2);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// void ( p1, p2, p3 )
handlers.Reset();
- signals.SignalVoid3Value().Connect( &StaticFunctionHandlers::VoidSlot3Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
- signals.EmitVoidSignal3IntValue( 1, 2, 3 );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+ signals.SignalVoid3Value().Connect(&StaticFunctionHandlers::VoidSlot3Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
+ signals.EmitVoidSignal3IntValue(1, 2, 3);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// ret ( )
handlers.Reset();
- signals.SignalFloat0().Connect( &StaticFunctionHandlers::RetSlot0Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
+ signals.SignalFloat0().Connect(&StaticFunctionHandlers::RetSlot0Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
signals.EmitFloat0Signal();
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// ret ( p1 )
handlers.Reset();
- signals.SignalFloat1Value().Connect( &StaticFunctionHandlers::RetSlot1Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
- signals.EmitFloat1VSignal( 1.f );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+ signals.SignalFloat1Value().Connect(&StaticFunctionHandlers::RetSlot1Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
+ signals.EmitFloat1VSignal(1.f);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// ret ( p1, p2 )
handlers.Reset();
- signals.SignalFloat2Value().Connect( &StaticFunctionHandlers::RetSlot2Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
- signals.EmitFloat2VSignal( 1.f, 2.f );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
-
+ signals.SignalFloat2Value().Connect(&StaticFunctionHandlers::RetSlot2Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
+ signals.EmitFloat2VSignal(1.f, 2.f);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
// ret ( p1, p2, p3 )
handlers.Reset();
- signals.SignalFloat3Value().Connect( &StaticFunctionHandlers::RetSlot3Param );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, false, TEST_LOCATION );
- signals.EmitFloat3VSignal( 1.f, 2.f, 3.f );
- DALI_TEST_EQUALS( handlers.staticFunctionHandled, true, TEST_LOCATION );
+ signals.SignalFloat3Value().Connect(&StaticFunctionHandlers::RetSlot3Param);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, false, TEST_LOCATION);
+ signals.EmitFloat3VSignal(1.f, 2.f, 3.f);
+ DALI_TEST_EQUALS(handlers.staticFunctionHandled, true, TEST_LOCATION);
END_TEST;
-
}
-
int UtcDaliSignalDisconnect(void)
{
// Test that callbacks don't occur if a signal is disconnected before emission
{
TestSlotHandler handlers;
signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- int r = 7;
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ int r = 7;
handlers.mIntReturn = 5;
signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
signals.EmitVoidSignalIntRef(r);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalVoid1Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
signals.EmitVoidSignal1IntValue(5);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalVoid2Value().Connect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
signals.EmitVoidSignal2IntValue(5, 10);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalBool1Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalBool2Value().Connect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalInt2Value().Connect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mIntReturn = 27;
signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalFloat0().Connect(&handlers, &TestSlotHandler::FloatSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
signals.EmitFloat0Signal();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalFloat2Value().Connect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
signals.EmitFloat2VSignal(5, 33.0f);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
END_TEST;
}
TestSlotHandler handlers;
signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
}
{
TestSlotHandler handlers;
- int r = 7;
+ int r = 7;
signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
signals.EmitVoidSignalIntRef(r);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalVoid1Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValue);
signals.EmitVoidSignal1IntValue(5);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalVoid2Value().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntValueIntValue);
signals.EmitVoidSignal2IntValue(5, 10);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
}
{
TestSlotHandler handlers;
handlers.mBoolReturn = true;
signals.SignalBool1Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
}
{
TestSlotHandler handlers;
handlers.mBoolReturn = true;
signals.SignalBool2Value().Disconnect(&handlers, &TestSlotHandler::BoolSlotFloatValueIntValue);
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
}
{
handlers.mIntReturn = 27;
signals.SignalInt2Value().Disconnect(&handlers, &TestSlotHandler::IntSlotFloatValueIntValue);
signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
{
handlers.mFloatReturn = 27.0f;
signals.SignalFloat2Value().Disconnect(&handlers, &TestSlotHandler::FloatSlotFloatValueFloatValue);
signals.EmitFloat2VSignal(5, 33.0f);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
{
handlers.mFloatReturn = 27.0f;
signals.SignalFloat0().Disconnect(&handlers, &TestSlotHandler::FloatSlotVoid);
signals.EmitFloat0Signal();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
END_TEST;
}
{
TestSlotHandler handlers;
signals.SignalVoidNone().Connect(&handlers, &TestSlotHandler::VoidSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
// Emit first
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
// Disconnect and emit again
handlers.mHandled = false;
signals.SignalVoidNone().Disconnect(&handlers, &TestSlotHandler::VoidSlotVoid);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
}
{
TestSlotHandler handlers;
signals.SignalVoid1Ref().Connect(&handlers, &TestSlotHandler::VoidSlotIntRef);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
int r = 7;
// Emit first
signals.EmitVoidSignalIntRef(r);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
// Disconnect and emit again
- handlers.mHandled = false;
+ handlers.mHandled = false;
handlers.mIntParam1 = 0;
signals.SignalVoid1Ref().Disconnect(&handlers, &TestSlotHandler::VoidSlotIntRef);
signals.EmitVoidSignalIntRef(r);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
}
END_TEST;
}
{
TestSignals::VoidRetNoParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestBasicConnectionTrackerInterface customTracker;
- signal.Connect( &customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(&customTracker, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
signal.Emit();
// Test signal emission & destruction
{
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(signal.Empty());
+ DALI_TEST_EQUALS(0u, customTracker2.GetConnectionCount(), TEST_LOCATION);
- signal.Connect( &customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- DALI_TEST_EQUALS( 1u, customTracker2.GetConnectionCount(), TEST_LOCATION );
+ signal.Connect(&customTracker2, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
+ DALI_TEST_EQUALS(1u, customTracker2.GetConnectionCount(), TEST_LOCATION);
- DALI_TEST_EQUALS( customTracker2.mCallbackHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(customTracker2.mCallbackHandled, false, TEST_LOCATION);
signal.Emit();
- DALI_TEST_EQUALS( customTracker2.mCallbackHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(customTracker2.mCallbackHandled, true, TEST_LOCATION);
}
- DALI_TEST_EQUALS( 0u, customTracker2.GetConnectionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, customTracker2.GetConnectionCount(), TEST_LOCATION);
// Test for removing a null callback
{
- TestBasicConnectionTrackerInterface customTracker3;
-
- TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
- DALI_TEST_EQUALS( 0u, customTracker3.GetConnectionCount(), TEST_LOCATION );
-
- signal.Connect( &customTracker3, &TestBasicConnectionTrackerInterface::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
- DALI_TEST_EQUALS( 1u, customTracker3.GetConnectionCount(), TEST_LOCATION );
- try
- {
- // should assert
- customTracker3.RemoveNullCallback();
- tet_result( TET_FAIL );
- }
- catch (Dali::DaliException& e)
- {
- tet_result( TET_PASS );
- }
- }
+ TestBasicConnectionTrackerInterface customTracker3;
+
+ TestSignals::VoidRetNoParamSignal signal;
+ DALI_TEST_CHECK(signal.Empty());
+ DALI_TEST_EQUALS(0u, customTracker3.GetConnectionCount(), TEST_LOCATION);
+
+ signal.Connect(&customTracker3, &TestBasicConnectionTrackerInterface::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
+ DALI_TEST_EQUALS(1u, customTracker3.GetConnectionCount(), TEST_LOCATION);
+ try
+ {
+ // should assert
+ customTracker3.RemoveNullCallback();
+ tet_result(TET_FAIL);
+ }
+ catch(Dali::DaliException& e)
+ {
+ tet_result(TET_PASS);
+ }
+ }
END_TEST;
}
{
TestSlotHandler handler1;
- signals.SignalVoidNone().Connect( &handler1, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
+ signals.SignalVoidNone().Connect(&handler1, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
TestSlotHandler handler2;
- signals.SignalVoidNone().Connect( &handler2, &TestSlotHandler::VoidSlotVoid );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
+ signals.SignalVoidNone().Connect(&handler2, &TestSlotHandler::VoidSlotVoid);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
// Remove first connection and repeat
handler1.Reset();
handler2.Reset();
- signals.SignalVoidNone().Disconnect( &handler1, &TestSlotHandler::VoidSlotVoid );
+ signals.SignalVoidNone().Disconnect(&handler1, &TestSlotHandler::VoidSlotVoid);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
}
{
TestSlotHandler handler1;
- signals.SignalVoid1Ref().Connect( &handler1, &TestSlotHandler::VoidSlotIntRef );
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Ref().Connect(&handler1, &TestSlotHandler::VoidSlotIntRef);
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
TestSlotHandler handler2;
- signals.SignalVoid1Ref().Connect( &handler2, &TestSlotHandler::VoidSlotIntRef );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Ref().Connect(&handler2, &TestSlotHandler::VoidSlotIntRef);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
int x = 7;
signals.EmitVoidSignalIntRef(x);
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 7, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mIntParam1, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 7, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mIntParam1, 7, TEST_LOCATION);
// Remove second connection and repeat
handler1.Reset();
handler2.Reset();
x = 8;
- signals.SignalVoid1Ref().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntRef );
+ signals.SignalVoid1Ref().Disconnect(&handler2, &TestSlotHandler::VoidSlotIntRef);
signals.EmitVoidSignalIntRef(x);
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 8, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 8, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mIntParam1, 0, TEST_LOCATION);
}
{
TestSlotHandler handler1;
- signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
TestSlotHandler handler2;
- signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
TestSlotHandler handler3;
- signals.SignalVoid1Value().Connect( &handler3, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Value().Connect(&handler3, &TestSlotHandler::VoidSlotIntValue);
+ DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
- signals.EmitVoidSignal1IntValue( 5 );
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 5, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mIntParam1, 5, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mIntParam1, 5, TEST_LOCATION );
+ signals.EmitVoidSignal1IntValue(5);
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mIntParam1, 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mIntParam1, 5, TEST_LOCATION);
// Remove middle connection and repeat
handler1.Reset();
handler2.Reset();
handler3.Reset();
- signals.SignalVoid1Value().Disconnect( &handler2, &TestSlotHandler::VoidSlotIntValue );
+ signals.SignalVoid1Value().Disconnect(&handler2, &TestSlotHandler::VoidSlotIntValue);
- signals.EmitVoidSignal1IntValue( 6 );
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mIntParam1, 6, TEST_LOCATION );
+ signals.EmitVoidSignal1IntValue(6);
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 6, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mIntParam1, 6, TEST_LOCATION);
}
// Test that multiple callbacks are disconnected when a signal is destroyed
{
TestSignals::VoidRet1ValueParamSignal tempSignal;
- DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler4.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler5.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler6.GetConnectionCount(), 0u, TEST_LOCATION);
- tempSignal.Connect( &handler4, &TestSlotHandler::VoidSlotIntValue );
- tempSignal.Connect( &handler5, &TestSlotHandler::VoidSlotIntValue );
- tempSignal.Connect( &handler6, &TestSlotHandler::VoidSlotIntValue );
+ tempSignal.Connect(&handler4, &TestSlotHandler::VoidSlotIntValue);
+ tempSignal.Connect(&handler5, &TestSlotHandler::VoidSlotIntValue);
+ tempSignal.Connect(&handler6, &TestSlotHandler::VoidSlotIntValue);
- DALI_TEST_EQUALS( handler4.GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler5.GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler6.GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler4.GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler5.GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler6.GetConnectionCount(), 1u, TEST_LOCATION);
}
// End of tempSignal lifetime
- DALI_TEST_EQUALS( handler4.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler5.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler6.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler4.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler5.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler6.GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
TestSlotHandler handler1;
// Note the double connection is intentional
- signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
- signals.SignalVoid1Value().Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
+ signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
+ signals.SignalVoid1Value().Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
+ DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
- signals.EmitVoidSignal1IntValue( 6 );
- DALI_TEST_EQUALS( handler1.mHandledCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 6, TEST_LOCATION );
+ signals.EmitVoidSignal1IntValue(6);
+ DALI_TEST_EQUALS(handler1.mHandledCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 6, TEST_LOCATION);
// Calling Disconnect once should be enough
- signals.SignalVoid1Value().Disconnect( &handler1, &TestSlotHandler::VoidSlotIntValue );
- DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
+ signals.SignalVoid1Value().Disconnect(&handler1, &TestSlotHandler::VoidSlotIntValue);
+ DALI_TEST_CHECK(signals.SignalVoid1Value().Empty());
handler1.mIntParam1 = 0;
- signals.EmitVoidSignal1IntValue( 7 );
- DALI_TEST_EQUALS( handler1.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
+ signals.EmitVoidSignal1IntValue(7);
+ DALI_TEST_EQUALS(handler1.mHandledCount, 1 /*not incremented since last check*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 0, TEST_LOCATION);
}
// Test automatic disconnect after multiple Connect() calls
{
TestSlotHandler handler2;
- signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
- signals.SignalVoid1Value().Connect( &handler2, &TestSlotHandler::VoidSlotIntValue );
+ signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
+ signals.SignalVoid1Value().Connect(&handler2, &TestSlotHandler::VoidSlotIntValue);
TestSlotHandler handler3;
- signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler3, &TestSlotHandler::BoolSlotFloatValue );
+ signals.SignalBool1Value().Connect(&handler3, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler3, &TestSlotHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( handler2.mHandledCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mHandledCount, 0, TEST_LOCATION );
- DALI_TEST_CHECK( ! signals.SignalVoid1Value().Empty() );
- DALI_TEST_CHECK( ! signals.SignalBool1Value().Empty() );
+ DALI_TEST_EQUALS(handler2.mHandledCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mHandledCount, 0, TEST_LOCATION);
+ DALI_TEST_CHECK(!signals.SignalVoid1Value().Empty());
+ DALI_TEST_CHECK(!signals.SignalBool1Value().Empty());
}
- DALI_TEST_CHECK( signals.SignalVoid1Value().Empty() );
- DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
+ DALI_TEST_CHECK(signals.SignalVoid1Value().Empty());
+ DALI_TEST_CHECK(signals.SignalBool1Value().Empty());
// Should be NOOP
- signals.EmitVoidSignal1IntValue( 1 );
- signals.EmitBoolSignalFloatValue( 1.0f );
+ signals.EmitVoidSignal1IntValue(1);
+ signals.EmitBoolSignalFloatValue(1.0f);
// Test that connecting the same callback 10 times is a NOOP
TestSlotHandler handler4;
- DALI_TEST_EQUALS( handler4.mHandledCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handler4.mFloatParam1, 0.0f, TEST_LOCATION );
-
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- signals.SignalBool1Value().Connect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
-
- signals.EmitBoolSignalFloatValue( 2.0f );
- DALI_TEST_EQUALS( handler4.mHandledCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler4.mHandledCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler4.mFloatParam1, 0.0f, TEST_LOCATION);
+
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ signals.SignalBool1Value().Connect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+
+ signals.EmitBoolSignalFloatValue(2.0f);
+ DALI_TEST_EQUALS(handler4.mHandledCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler4.mFloatParam1, 2.0f, TEST_LOCATION);
// Calling Disconnect once should be enough
- signals.SignalBool1Value().Disconnect( &handler4, &TestSlotHandler::BoolSlotFloatValue );
- DALI_TEST_CHECK( signals.SignalBool1Value().Empty() );
+ signals.SignalBool1Value().Disconnect(&handler4, &TestSlotHandler::BoolSlotFloatValue);
+ DALI_TEST_CHECK(signals.SignalBool1Value().Empty());
- signals.EmitBoolSignalFloatValue( 3.0f );
- DALI_TEST_EQUALS( handler4.mHandledCount, 1/*not incremented since last check*/, TEST_LOCATION );
- DALI_TEST_EQUALS( handler4.mFloatParam1, 2.0f, TEST_LOCATION );
+ signals.EmitBoolSignalFloatValue(3.0f);
+ DALI_TEST_EQUALS(handler4.mHandledCount, 1 /*not incremented since last check*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler4.mFloatParam1, 2.0f, TEST_LOCATION);
END_TEST;
}
{
TestSignals::VoidRet1ValueParamSignal tempSignal;
- DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 0, TEST_LOCATION);
// Note that the duplicate connection is deliberate
- tempSignal.Connect( &handler1, &TestSlotHandler::VoidSlotIntValue );
- tempSignal.Connect( &handler1, &TestSlotHandler::VoidDuplicateSlotIntValue );
+ tempSignal.Connect(&handler1, &TestSlotHandler::VoidSlotIntValue);
+ tempSignal.Connect(&handler1, &TestSlotHandler::VoidDuplicateSlotIntValue);
- DALI_TEST_EQUALS( handler1.GetConnectionCount(), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mHandledCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.GetConnectionCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mHandledCount, 0, TEST_LOCATION);
- tempSignal.Emit( 10 );
+ tempSignal.Emit(10);
- DALI_TEST_EQUALS( handler1.mHandledCount, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam1, 10, TEST_LOCATION );
- DALI_TEST_EQUALS( handler1.mIntParam2, 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandledCount, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam1, 10, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler1.mIntParam2, 10, TEST_LOCATION);
}
// End of tempSignal lifetime
- DALI_TEST_EQUALS( handler1.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliSignalDisconnectStatic(void)
{
// void Func()
{
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
- signal.Connect( StaticVoidCallbackVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(StaticVoidCallbackVoid);
+ DALI_TEST_CHECK(!signal.Empty());
wasStaticVoidCallbackVoidCalled = false;
signal.Emit();
- DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(wasStaticVoidCallbackVoidCalled, true, TEST_LOCATION);
- signal.Disconnect( StaticVoidCallbackVoid );
- DALI_TEST_CHECK( signal.Empty() );
+ signal.Disconnect(StaticVoidCallbackVoid);
+ DALI_TEST_CHECK(signal.Empty());
wasStaticVoidCallbackVoidCalled = false;
signal.Emit();
- DALI_TEST_EQUALS( wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(wasStaticVoidCallbackVoidCalled, false, TEST_LOCATION);
}
// float Func()
{
TestSignals::FloatRet0ParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
- signal.Connect( StaticFloatCallbackVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(StaticFloatCallbackVoid);
+ DALI_TEST_CHECK(!signal.Empty());
wasStaticFloatCallbackVoidCalled = false;
- float result = signal.Emit();
- DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( result, 7.0f, TEST_LOCATION );
+ float result = signal.Emit();
+ DALI_TEST_EQUALS(wasStaticFloatCallbackVoidCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(result, 7.0f, TEST_LOCATION);
- signal.Disconnect( StaticFloatCallbackVoid );
- DALI_TEST_CHECK( signal.Empty() );
+ signal.Disconnect(StaticFloatCallbackVoid);
+ DALI_TEST_CHECK(signal.Empty());
wasStaticFloatCallbackVoidCalled = false;
- result = signal.Emit();
- DALI_TEST_EQUALS( wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
+ result = signal.Emit();
+ DALI_TEST_EQUALS(wasStaticFloatCallbackVoidCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(result, 0.0f, TEST_LOCATION);
}
// void Func( int )
{
TestSignals::VoidRet1ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
- signal.Connect( StaticVoidCallbackIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(StaticVoidCallbackIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
wasStaticVoidCallbackIntValueCalled = false;
- staticIntValue = 0;
- signal.Emit( 10 );
- DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( staticIntValue, 10, TEST_LOCATION );
+ staticIntValue = 0;
+ signal.Emit(10);
+ DALI_TEST_EQUALS(wasStaticVoidCallbackIntValueCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(staticIntValue, 10, TEST_LOCATION);
- signal.Disconnect( StaticVoidCallbackIntValue );
- DALI_TEST_CHECK( signal.Empty() );
+ signal.Disconnect(StaticVoidCallbackIntValue);
+ DALI_TEST_CHECK(signal.Empty());
wasStaticVoidCallbackIntValueCalled = false;
- staticIntValue = 0;
- signal.Emit( 11 );
- DALI_TEST_EQUALS( wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( staticIntValue, 0, TEST_LOCATION );
+ staticIntValue = 0;
+ signal.Emit(11);
+ DALI_TEST_EQUALS(wasStaticVoidCallbackIntValueCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(staticIntValue, 0, TEST_LOCATION);
}
// float Func( float, float )
{
TestSignals::FloatRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
- signal.Connect( StaticFloatCallbackFloatValueFloatValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(StaticFloatCallbackFloatValueFloatValue);
+ DALI_TEST_CHECK(!signal.Empty());
wasStaticFloatCallbackFloatValueFloatValueCalled = false;
- staticFloatValue1 = 0.0f;
- staticFloatValue2 = 0.0f;
- float result = signal.Emit( 5.0f, 6.0f );
- DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( staticFloatValue1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( staticFloatValue2, 6.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( result, 5.0f+6.0f, TEST_LOCATION );
+ staticFloatValue1 = 0.0f;
+ staticFloatValue2 = 0.0f;
+ float result = signal.Emit(5.0f, 6.0f);
+ DALI_TEST_EQUALS(wasStaticFloatCallbackFloatValueFloatValueCalled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(staticFloatValue1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(staticFloatValue2, 6.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(result, 5.0f + 6.0f, TEST_LOCATION);
- signal.Disconnect( StaticFloatCallbackFloatValueFloatValue );
- DALI_TEST_CHECK( signal.Empty() );
+ signal.Disconnect(StaticFloatCallbackFloatValueFloatValue);
+ DALI_TEST_CHECK(signal.Empty());
wasStaticFloatCallbackFloatValueFloatValueCalled = false;
- staticFloatValue1 = 0.0f;
- staticFloatValue2 = 0.0f;
- result = signal.Emit( 7.0f, 8.0f );
- DALI_TEST_EQUALS( wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( staticFloatValue1, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( staticFloatValue2, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( result, 0.0f, TEST_LOCATION );
+ staticFloatValue1 = 0.0f;
+ staticFloatValue2 = 0.0f;
+ result = signal.Emit(7.0f, 8.0f);
+ DALI_TEST_EQUALS(wasStaticFloatCallbackFloatValueFloatValueCalled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(staticFloatValue1, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(staticFloatValue2, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(result, 0.0f, TEST_LOCATION);
}
END_TEST;
}
// Test disconnection during each callback
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDisconnector handler1;
- handler1.VoidConnectVoid( signal );
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
- DALI_TEST_CHECK( ! signal.Empty() );
+ handler1.VoidConnectVoid(signal);
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_CHECK(signal.Empty());
// Repeat with 2 callbacks
handler1.mHandled = false;
TestSlotDisconnector handler2;
- handler1.VoidConnectVoid( signal );
- handler2.VoidConnectVoid( signal );
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
- DALI_TEST_CHECK( ! signal.Empty() );
+ handler1.VoidConnectVoid(signal);
+ handler2.VoidConnectVoid(signal);
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
+ DALI_TEST_CHECK(signal.Empty());
// Repeat with no callbacks
handler2.mHandled = false;
signal.Emit();
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
// Repeat with 3 callbacks
TestSlotDisconnector handler3;
- handler1.VoidConnectVoid( signal );
- handler2.VoidConnectVoid( signal );
- handler3.VoidConnectVoid( signal );
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
- DALI_TEST_CHECK( ! signal.Empty() );
+ handler1.VoidConnectVoid(signal);
+ handler2.VoidConnectVoid(signal);
+ handler3.VoidConnectVoid(signal);
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
- DALI_TEST_EQUALS( handler1.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mHandled, true, TEST_LOCATION );
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_EQUALS(handler1.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mHandled, true, TEST_LOCATION);
+ DALI_TEST_CHECK(signal.Empty());
// Repeat with no callbacks
handler3.mHandled = false;
signal.Emit();
- DALI_TEST_EQUALS( handler1.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler2.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler3.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler1.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler2.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler3.mHandled, false, TEST_LOCATION);
END_TEST;
}
// Test disconnection of some (but not all) callbacks during sigmal emission
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotMultiDisconnector handler;
- handler.ConnectAll( signal );
- DALI_TEST_EQUALS( handler.mSlotHandled[0], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[1], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[2], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[3], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[4], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[6], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[8], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
- DALI_TEST_CHECK( ! signal.Empty() );
+ handler.ConnectAll(signal);
+ DALI_TEST_EQUALS(handler.mSlotHandled[0], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[1], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[2], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[3], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[4], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[5], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[6], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[7], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[8], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[9], false, TEST_LOCATION);
+ DALI_TEST_CHECK(!signal.Empty());
signal.Emit();
// Slots 5, 7, & 9 should be disconnected before being called
- DALI_TEST_EQUALS( handler.mSlotHandled[0], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[1], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[2], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[3], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[4], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[5], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[6], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[7], false, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[8], true, TEST_LOCATION );
- DALI_TEST_EQUALS( handler.mSlotHandled[9], false, TEST_LOCATION );
- DALI_TEST_CHECK( ! signal.Empty() );
+ DALI_TEST_EQUALS(handler.mSlotHandled[0], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[1], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[2], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[3], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[4], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[5], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[6], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[7], false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[8], true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handler.mSlotHandled[9], false, TEST_LOCATION);
+ DALI_TEST_CHECK(!signal.Empty());
// Odd slots are disconnected
- DALI_TEST_EQUALS( handler.GetConnectionCount(), 5u, TEST_LOCATION );
+ DALI_TEST_EQUALS(handler.GetConnectionCount(), 5u, TEST_LOCATION);
END_TEST;
}
// for coverage purposes we test the emit guard for each signal type (0,1,2,3 params) void / return value
{
TestSignals::VoidRetNoParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestEmitDuringCallback handler1;
- handler1.VoidConnectVoid( signal );
+ handler1.VoidConnectVoid(signal);
// Test that this does not result in an infinite loop!
signal.Emit();
{
TestSignals::FloatRet0ParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestEmitDuringCallback handler1;
- handler1.FloatRet0ParamConnect( signal );
+ handler1.FloatRet0ParamConnect(signal);
// Test that this does not result in an infinite loop!
signal.Emit();
{
TestSignals::FloatRet1ParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestEmitDuringCallback handler1;
- handler1.FloatRet1ParamConnect( signal );
+ handler1.FloatRet1ParamConnect(signal);
// Test that this does not result in an infinite loop!
- signal.Emit( 1.f );
+ signal.Emit(1.f);
}
{
TestSignals::FloatRet2ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestEmitDuringCallback handler1;
- handler1.FloatRet2ParamConnect( signal );
+ handler1.FloatRet2ParamConnect(signal);
// Test that this does not result in an infinite loop!
- signal.Emit( 1.f, 1.f );
+ signal.Emit(1.f, 1.f);
}
{
TestSignals::FloatRet3ValueParamSignal signal;
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestEmitDuringCallback handler1;
- handler1.FloatRet3ParamConnect( signal );
+ handler1.FloatRet3ParamConnect(signal);
// Test that this does not result in an infinite loop!
- signal.Emit( 1.f,1.f,1.f );
+ signal.Emit(1.f, 1.f, 1.f);
}
END_TEST;
}
TestSignals::VoidRetNoParamSignal* signal = new TestSignals::VoidRetNoParamSignal;
TestEmitDuringCallback handler1;
- handler1.DeleteDuringEmitConnect( *signal );
+ handler1.DeleteDuringEmitConnect(*signal);
// should just log an error
signal->Emit();
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
END_TEST;
}
// Signal dies first.
TestButton* button = new TestButton(1);
- TestApp app;
- button->DownSignal().Connect(&app,&TestApp::OnButtonPress);
+ TestApp app;
+ button->DownSignal().Connect(&app, &TestApp::OnButtonPress);
// check we have both the button, and the app have 1 connection
- DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
- delete button; // should automatically destroy the connection
+ delete button; // should automatically destroy the connection
// check we have a 0 connections
- DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
// Slot owning object dies first.
TestButton button(1);
- TestApp *app = new TestApp;
- button.DownSignal().Connect( app, &TestApp::OnButtonPress);
+ TestApp* app = new TestApp;
+ button.DownSignal().Connect(app, &TestApp::OnButtonPress);
// check we have a 1 connection
- DALI_TEST_EQUALS( app->GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app->GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
- delete app; // should automatically destroy the connection
+ delete app; // should automatically destroy the connection
// check we have a 0 connections
- DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
// 1 of the slot owners dies. Then the second slot owner dies
TestButton button(1);
- TestApp *app1 = new TestApp;
- TestApp *app2 = new TestApp;
+ TestApp* app1 = new TestApp;
+ TestApp* app2 = new TestApp;
- button.DownSignal().Connect( app1, &TestApp::OnButtonPress);
- button.DownSignal().Connect( app2, &TestApp::OnButtonPress);
+ button.DownSignal().Connect(app1, &TestApp::OnButtonPress);
+ button.DownSignal().Connect(app2, &TestApp::OnButtonPress);
- // check we have a 2 connections to the signal
- DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
+ // check we have a 2 connections to the signal
+ DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
// kill the first slot
- delete app1; // should automatically destroy the connection
+ delete app1; // should automatically destroy the connection
// check we have 1 connection left
- DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
- button.Press(); // emit the signal (to ensure it doesn't seg fault)
+ button.Press(); // emit the signal (to ensure it doesn't seg fault)
// kill the second slot
- delete app2; // should automatically destroy the connection
+ delete app2; // should automatically destroy the connection
// check we have 1 connection left
- DALI_TEST_EQUALS( button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(button.DownSignal().GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
// The Signal dies, check the 2 slots disconnect automatically
TestButton* button = new TestButton(1);
- TestApp app1;
- TestApp app2;
+ TestApp app1;
+ TestApp app2;
- button->DownSignal().Connect(&app1,&TestApp::OnButtonPress);
- button->DownSignal().Connect(&app2,&TestApp::OnButtonPress);
+ button->DownSignal().Connect(&app1, &TestApp::OnButtonPress);
+ button->DownSignal().Connect(&app2, &TestApp::OnButtonPress);
// check the connection counts
- DALI_TEST_EQUALS( app1.GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( app2.GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app1.GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(app2.GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(button->DownSignal().GetConnectionCount(), 2u, TEST_LOCATION);
- delete button; // should automatically destroy the connection
+ delete button; // should automatically destroy the connection
// check both slot owners have zero connections
- DALI_TEST_EQUALS( app1.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( app2.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app1.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(app2.GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
TestApp app;
- button1->DownSignal().Connect(&app,&TestApp::OnButtonPress);
- button2->DownSignal().Connect(&app,&TestApp::OnButtonPress);
+ button1->DownSignal().Connect(&app, &TestApp::OnButtonPress);
+ button2->DownSignal().Connect(&app, &TestApp::OnButtonPress);
// check the connection counts
- DALI_TEST_EQUALS( app.GetConnectionCount(), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetConnectionCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(button1->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(button2->DownSignal().GetConnectionCount(), 1u, TEST_LOCATION);
// make sure both signals emit ok
button2->Press();
- DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
button1->Press();
- DALI_TEST_EQUALS( app.GetButtonPressedId() , 1 , TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetButtonPressedId(), 1, TEST_LOCATION);
- delete button1; // should automatically destroy 1 connection
+ delete button1; // should automatically destroy 1 connection
// check both slot owners have zero connections
- DALI_TEST_EQUALS( app.GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetConnectionCount(), 1u, TEST_LOCATION);
// check remaining connection still works
button2->Press();
- DALI_TEST_EQUALS( app.GetButtonPressedId() , 2 , TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetButtonPressedId(), 2, TEST_LOCATION);
// kill the last signal
delete button2;
- DALI_TEST_EQUALS( app.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(app.GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
int UtcDaliSignalTestApp06(void)
{
- Signal< bool () > boolSignal;
- TestApp app;
- bool result(false);
+ Signal<bool()> boolSignal;
+ TestApp app;
+ bool result(false);
// connect a slot which will return false
- boolSignal.Connect( &app, &TestApp::BoolReturnTestFalse);
+ boolSignal.Connect(&app, &TestApp::BoolReturnTestFalse);
result = boolSignal.Emit();
- DALI_TEST_EQUALS( result, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(result, false, TEST_LOCATION);
// disconnect last slot, and connect a slot which returns true
- boolSignal.Disconnect( &app, &TestApp::BoolReturnTestFalse);
- boolSignal.Connect( &app, &TestApp::BoolReturnTestTrue);
+ boolSignal.Disconnect(&app, &TestApp::BoolReturnTestFalse);
+ boolSignal.Connect(&app, &TestApp::BoolReturnTestTrue);
result = boolSignal.Emit();
- DALI_TEST_EQUALS( result, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(result, true, TEST_LOCATION);
END_TEST;
}
{
TestSlotDelegateHandler handlers;
- signals.SignalVoidNone().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
// Test double emission
handlers.mHandled = false;
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalVoid1Ref().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
int x = 7;
signals.EmitVoidSignalIntRef(x);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 7, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalVoid1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignal1IntValue(5);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 5, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 5, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalVoid2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignal2IntValue(6, 7);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 6, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 6, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 7, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalBool1Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
// repeat with opposite return value
handlers.mBoolReturn = false;
- handlers.mHandled = false;
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 6.0f, TEST_LOCATION );
+ handlers.mHandled = false;
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(6.0f), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 6.0f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalBool2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 10, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalInt2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mIntReturn = 27;
- int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
- DALI_TEST_EQUALS( x, 27, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 33.5f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 5, TEST_LOCATION );
+ int x = signals.EmitIntSignalFloatValueIntValue(33.5f, 5);
+ DALI_TEST_EQUALS(x, 27, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 33.5f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 5, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalFloat0().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
- float f = signals.EmitFloat0Signal();
- DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ float f = signals.EmitFloat0Signal();
+ DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalFloat2Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
- float f = signals.EmitFloat2VSignal(5, 33.0f);
- DALI_TEST_EQUALS( f, 27.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
+ float f = signals.EmitFloat2VSignal(5, 33.0f);
+ DALI_TEST_EQUALS(f, 27.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.VoidSignalFloatValue3().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3 );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.VoidSignalFloatValue3().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotFloatValue3);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.EmitVoidSignalFloatValue3(5, 33.0f, 100.0f);
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
{
TestSlotDelegateHandler handlers;
- signals.SignalFloat3Value().Connect( handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3 );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ signals.SignalFloat3Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValue3);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
- float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
- DALI_TEST_EQUALS( returnValue, 27.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, true, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION );
+ float returnValue = signals.EmitFloat3VSignal(5, 33.0f, 100.0f);
+ DALI_TEST_EQUALS(returnValue, 27.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 33.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam3, 100.0f, 0.001f, TEST_LOCATION);
}
signals.CheckNoConnections();
END_TEST;
{
TestSignals::VoidRetNoParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
signal.Emit();
{
TestSignals::VoidRet1ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- signal.Emit( 10 );
+ signal.Emit(10);
}
{
TestSignals::VoidRet1RefParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- int temp( 5 );
- signal.Emit( temp );
+ int temp(5);
+ signal.Emit(temp);
}
{
TestSignals::VoidRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- signal.Emit( 1, 2 );
+ signal.Emit(1, 2);
}
{
TestSignals::BoolRet1ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- bool blah = signal.Emit( 1.0f );
- DALI_TEST_CHECK( ! blah );
+ bool blah = signal.Emit(1.0f);
+ DALI_TEST_CHECK(!blah);
}
{
TestSignals::BoolRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- bool blah = signal.Emit( 1.0f, 2 );
- DALI_TEST_CHECK( ! blah );
+ bool blah = signal.Emit(1.0f, 2);
+ DALI_TEST_CHECK(!blah);
}
{
TestSignals::IntRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- int blah = signal.Emit( 10.0f, 100 );
- DALI_TEST_CHECK( 0 == blah );
+ int blah = signal.Emit(10.0f, 100);
+ DALI_TEST_CHECK(0 == blah);
}
{
TestSignals::FloatRet0ParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
- signal.Connect( handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid );
- DALI_TEST_CHECK( ! signal.Empty() );
+ signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
float blah = signal.Emit();
- DALI_TEST_CHECK( 0.0f == blah );
+ DALI_TEST_CHECK(0.0f == blah);
}
{
TestSignals::FloatRet2ValueParamSignal signal;
{
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
TestSlotDelegateHandler handler;
signal.Connect(handler.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_CHECK( ! signal.Empty() );
+ DALI_TEST_CHECK(!signal.Empty());
}
// End of slot lifetime
- DALI_TEST_CHECK( signal.Empty() );
+ DALI_TEST_CHECK(signal.Empty());
// Signal emission should be a NOOP
- float blah = signal.Emit( 3.0f, 4.0f );
- DALI_TEST_CHECK( 0.0f == blah );
+ float blah = signal.Emit(3.0f, 4.0f);
+ DALI_TEST_CHECK(0.0f == blah);
}
END_TEST;
}
{
TestSlotDelegateHandler handlers;
signals.SignalVoidNone().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.SignalVoidNone().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotVoid);
signals.EmitVoidSignalVoid();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalVoid1Ref().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- int r = 7;
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ int r = 7;
handlers.mIntReturn = 5;
signals.SignalVoid1Ref().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntRef);
signals.EmitVoidSignalIntRef(r);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( r, 7, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(r, 7, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalVoid1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.SignalVoid1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValue);
signals.EmitVoidSignal1IntValue(5);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalVoid2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
signals.SignalVoid2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::VoidSlotIntValueIntValue);
signals.EmitVoidSignal2IntValue(5, 10);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
signals.SignalBool1Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValue(5.0f), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalBool2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mBoolReturn = true;
signals.SignalBool2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValueIntValue);
- DALI_TEST_EQUALS( signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam2, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(signals.EmitBoolSignalFloatValueIntValue(5.0f, 10), false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam2, 0, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalInt2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mIntReturn = 27;
signals.SignalInt2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::IntSlotFloatValueIntValue);
signals.EmitIntSignalFloatValueIntValue(5, 33.0f);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mIntParam1, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mIntParam1, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalFloat0().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
signals.SignalFloat0().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotVoid);
signals.EmitFloat0Signal();
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
{
TestSlotDelegateHandler handlers;
signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
handlers.mFloatReturn = 27.0f;
signals.SignalFloat2Value().Disconnect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
signals.EmitFloat2VSignal(5, 33.0f);
- DALI_TEST_EQUALS( handlers.mHandled, false, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION );
- DALI_TEST_EQUALS( handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION );
+ DALI_TEST_EQUALS(handlers.mHandled, false, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam1, 0.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(handlers.mFloatParam2, 0.0f, 0.001f, TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliCallbackBase(void)
{
// simple constructor for coverage
CallbackBase base;
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
END_TEST;
}
TestSignals signals;
TestSlotDelegateHandler handlers;
- DALI_TEST_EQUALS( 0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
signals.SignalFloat2Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::FloatSlotFloatValueFloatValue);
- DALI_TEST_EQUALS( 1, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
signals.SignalBool1Value().Connect(handlers.mSlotDelegate, &TestSlotDelegateHandler::BoolSlotFloatValue);
- DALI_TEST_EQUALS( 2, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(2, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
handlers.mSlotDelegate.DisconnectAll();
- DALI_TEST_EQUALS( 0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0, handlers.mSlotDelegate.GetConnectionCount(), TEST_LOCATION);
END_TEST;
}
*/
// EXTERNAL INCLUDES
-#include <iostream>
#include <stdlib.h>
+#include <iostream>
+
// INTERNAL INCLUDES
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
using namespace Dali;
namespace
{
-
class TestSignals
{
public:
+ typedef Signal<void()> VoidSignalVoid;
+ typedef Signal<void(float)> VoidSignalFloat;
- typedef Signal<void ()> VoidSignalVoid;
- typedef Signal<void (float)> VoidSignalFloat;
-
- typedef Signal<float ()> FloatSignalVoid;
- typedef Signal<float (float)> FloatSignalFloat;
+ typedef Signal<float()> FloatSignalVoid;
+ typedef Signal<float(float)> FloatSignalFloat;
TestSignals()
{
void CheckNoConnections()
{
- DALI_TEST_EQUALS( mVoidSignalVoid.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mVoidSignalFloat.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(mVoidSignalVoid.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mVoidSignalFloat.GetConnectionCount(), 0u, TEST_LOCATION);
- DALI_TEST_EQUALS( mFloatSignalVoid.GetConnectionCount(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( mFloatSignalFloat.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(mFloatSignalVoid.GetConnectionCount(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(mFloatSignalFloat.GetConnectionCount(), 0u, TEST_LOCATION);
}
- VoidSignalVoid mVoidSignalVoid;
+ VoidSignalVoid mVoidSignalVoid;
VoidSignalFloat mVoidSignalFloat;
- FloatSignalVoid mFloatSignalVoid;
+ FloatSignalVoid mFloatSignalVoid;
FloatSignalFloat mFloatSignalFloat;
};
class TestConnectionTracker : public ConnectionTracker
{
public:
-
TestConnectionTracker()
{
}
++mCurrentInstanceCount;
}
- VoidFunctorVoid( const VoidFunctorVoid& copyMe )
+ VoidFunctorVoid(const VoidFunctorVoid& copyMe)
{
++mTotalInstanceCount;
++mCurrentInstanceCount;
struct VoidFunctorFloat
{
- VoidFunctorFloat( float* lastReceivedValue )
- : mLastReceivedValue( lastReceivedValue )
+ VoidFunctorFloat(float* lastReceivedValue)
+ : mLastReceivedValue(lastReceivedValue)
{
++mTotalInstanceCount;
++mCurrentInstanceCount;
}
- VoidFunctorFloat( const VoidFunctorFloat& copyMe )
- : mLastReceivedValue( copyMe.mLastReceivedValue )
+ VoidFunctorFloat(const VoidFunctorFloat& copyMe)
+ : mLastReceivedValue(copyMe.mLastReceivedValue)
{
++mTotalInstanceCount;
++mCurrentInstanceCount;
{
++mCallbackCount;
- if( mLastReceivedValue )
+ if(mLastReceivedValue)
{
*mLastReceivedValue = value;
}
++mCurrentInstanceCount;
}
- FloatFunctorVoid( const FloatFunctorVoid& copyMe )
+ FloatFunctorVoid(const FloatFunctorVoid& copyMe)
{
++mTotalInstanceCount;
++mCurrentInstanceCount;
++mCurrentInstanceCount;
}
- FloatFunctorFloat( const FloatFunctorFloat& copyMe )
- : mLastReceivedValue (copyMe.mLastReceivedValue )
+ FloatFunctorFloat(const FloatFunctorFloat& copyMe)
+ : mLastReceivedValue(copyMe.mLastReceivedValue)
{
++mTotalInstanceCount;
++mCurrentInstanceCount;
int FloatFunctorFloat::mCurrentInstanceCount = 0;
int FloatFunctorFloat::mCallbackCount = 0;
-} // anon namespace
-
+} // namespace
int UtcDaliSignalFunctorsEmptyCheck(void)
{
{
TestSignals::VoidSignalVoid signal;
- DALI_TEST_CHECK( signal.Empty() );
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_CHECK(signal.Empty());
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
TestConnectionTracker tracker;
- signal.Connect( &tracker, VoidFunctorVoid() );
- DALI_TEST_CHECK( ! signal.Empty() );
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION );
+ signal.Connect(&tracker, VoidFunctorVoid());
+ DALI_TEST_CHECK(!signal.Empty());
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
{
TestSignals::VoidSignalFloat signal;
- DALI_TEST_CHECK( signal.Empty() );
- DALI_TEST_EQUALS( VoidFunctorFloat::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_CHECK(signal.Empty());
+ DALI_TEST_EQUALS(VoidFunctorFloat::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION);
TestConnectionTracker tracker;
- signal.Connect( &tracker, VoidFunctorFloat(NULL) );
- DALI_TEST_CHECK( ! signal.Empty() );
- DALI_TEST_EQUALS( VoidFunctorFloat::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCurrentInstanceCount, 1, TEST_LOCATION );
+ signal.Connect(&tracker, VoidFunctorFloat(NULL));
+ DALI_TEST_CHECK(!signal.Empty());
+ DALI_TEST_EQUALS(VoidFunctorFloat::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCurrentInstanceCount, 1, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( VoidFunctorFloat::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorFloat::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION);
END_TEST;
}
{
TestConnectionTracker tracker;
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mVoidSignalVoid.Connect( &tracker, VoidFunctorVoid() );
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION );
+ signals.mVoidSignalVoid.Connect(&tracker, VoidFunctorVoid());
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION);
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION);
// Test double emission
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION);
signals.CheckNoConnections();
{
TestConnectionTracker tracker;
- float lastReceivedValue( 0.0f );
+ float lastReceivedValue(0.0f);
- DALI_TEST_EQUALS( VoidFunctorFloat::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorFloat::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mVoidSignalFloat.Connect( &tracker, VoidFunctorFloat(&lastReceivedValue) );
- DALI_TEST_EQUALS( VoidFunctorFloat::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCurrentInstanceCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCallbackCount, 0, TEST_LOCATION );
+ signals.mVoidSignalFloat.Connect(&tracker, VoidFunctorFloat(&lastReceivedValue));
+ DALI_TEST_EQUALS(VoidFunctorFloat::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCurrentInstanceCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCallbackCount, 0, TEST_LOCATION);
- signals.mVoidSignalFloat.Emit( 3.5f );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCallbackCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( lastReceivedValue, 3.5f, TEST_LOCATION );
+ signals.mVoidSignalFloat.Emit(3.5f);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCallbackCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(lastReceivedValue, 3.5f, TEST_LOCATION);
// Test double emission
- signals.mVoidSignalFloat.Emit( 7.0f );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCallbackCount, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( lastReceivedValue, 7.0f, TEST_LOCATION );
+ signals.mVoidSignalFloat.Emit(7.0f);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCallbackCount, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(lastReceivedValue, 7.0f, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( VoidFunctorFloat::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorFloat::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorFloat::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorFloat::mCallbackCount, 2, TEST_LOCATION);
signals.CheckNoConnections();
END_TEST;
}
{
TestConnectionTracker tracker;
- DALI_TEST_EQUALS( FloatFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(FloatFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mFloatSignalVoid.Connect( &tracker, FloatFunctorVoid() );
- DALI_TEST_EQUALS( FloatFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorVoid::mCallbackCount, 0, TEST_LOCATION );
+ signals.mFloatSignalVoid.Connect(&tracker, FloatFunctorVoid());
+ DALI_TEST_EQUALS(FloatFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCallbackCount, 0, TEST_LOCATION);
float returnValue = signals.mFloatSignalVoid.Emit();
- DALI_TEST_EQUALS( FloatFunctorVoid::mCallbackCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( returnValue, FloatFunctorVoid::DEFAULT_RETURN_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCallbackCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(returnValue, FloatFunctorVoid::DEFAULT_RETURN_VALUE, TEST_LOCATION);
// Test double emission
returnValue = signals.mFloatSignalVoid.Emit();
- DALI_TEST_EQUALS( FloatFunctorVoid::mCallbackCount, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( returnValue, FloatFunctorVoid::DEFAULT_RETURN_VALUE, TEST_LOCATION );
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCallbackCount, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(returnValue, FloatFunctorVoid::DEFAULT_RETURN_VALUE, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( FloatFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorVoid::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(FloatFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorVoid::mCallbackCount, 2, TEST_LOCATION);
signals.CheckNoConnections();
{
TestConnectionTracker tracker;
- DALI_TEST_EQUALS( FloatFunctorFloat::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(FloatFunctorFloat::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mFloatSignalFloat.Connect( &tracker, FloatFunctorFloat() );
- DALI_TEST_EQUALS( FloatFunctorFloat::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCurrentInstanceCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCallbackCount, 0, TEST_LOCATION );
+ signals.mFloatSignalFloat.Connect(&tracker, FloatFunctorFloat());
+ DALI_TEST_EQUALS(FloatFunctorFloat::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCurrentInstanceCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCallbackCount, 0, TEST_LOCATION);
- float returnValue = signals.mFloatSignalFloat.Emit( 0.1f );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCallbackCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( returnValue, 1.0f + 0.1f, TEST_LOCATION );
+ float returnValue = signals.mFloatSignalFloat.Emit(0.1f);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCallbackCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(returnValue, 1.0f + 0.1f, TEST_LOCATION);
// Test double emission
- returnValue = signals.mFloatSignalFloat.Emit( 0.2f );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCallbackCount, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( returnValue, 1.0f + 0.2f, TEST_LOCATION );
+ returnValue = signals.mFloatSignalFloat.Emit(0.2f);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCallbackCount, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(returnValue, 1.0f + 0.2f, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( FloatFunctorFloat::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( FloatFunctorFloat::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(FloatFunctorFloat::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCurrentInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(FloatFunctorFloat::mCallbackCount, 2, TEST_LOCATION);
signals.CheckNoConnections();
END_TEST;
}
{
TestConnectionTracker tracker;
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mVoidSignalVoid.Connect( &tracker, VoidFunctorVoid() );
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION );
+ signals.mVoidSignalVoid.Connect(&tracker, VoidFunctorVoid());
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION);
tracker.DisconnectAll();
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION);
// Test double emission
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION);
}
END_TEST;
}
{
TestSignals signals;
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mVoidSignalVoid.Connect( &tracker, VoidFunctorVoid() );
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION );
+ signals.mVoidSignalVoid.Connect(&tracker, VoidFunctorVoid());
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION);
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount,1, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION);
- DALI_TEST_EQUALS( tracker.GetConnectionCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracker.GetConnectionCount(), 1u, TEST_LOCATION);
}
// Functor should have been deleted with signal
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION);
- DALI_TEST_EQUALS( tracker.GetConnectionCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(tracker.GetConnectionCount(), 0u, TEST_LOCATION);
END_TEST;
}
{
TestConnectionTracker tracker;
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
- signals.mVoidSignalVoid.Connect( &tracker, FunctorDelegate::New( VoidFunctorVoid() ) );
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION );
+ signals.mVoidSignalVoid.Connect(&tracker, FunctorDelegate::New(VoidFunctorVoid()));
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 0, TEST_LOCATION);
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 1, TEST_LOCATION);
// Test double emission
signals.mVoidSignalVoid.Emit();
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION);
}
// TestConnectionTracker should auto-disconnect
- DALI_TEST_EQUALS( VoidFunctorVoid::mTotalInstanceCount, 2/*temporary copy + signal copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(VoidFunctorVoid::mTotalInstanceCount, 2 /*temporary copy + signal copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCurrentInstanceCount, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(VoidFunctorVoid::mCallbackCount, 2, TEST_LOCATION);
signals.CheckNoConnections();
END_TEST;
}
*/
// EXTERNAL INCLUDES
-#include <stdlib.h>
-#include <iostream>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/common/singleton-service.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
class TestHandle : public BaseHandle
{
public:
- TestHandle() {}
- TestHandle( BaseObject* object ) : BaseHandle( object ) {}
+ TestHandle()
+ {
+ }
+ TestHandle(BaseObject* object)
+ : BaseHandle(object)
+ {
+ }
};
class TestObject : public BaseObject
// Attempt to retrieve SingletonService before creating application
SingletonService singletonService;
singletonService = SingletonService::Get();
- DALI_TEST_CHECK( !singletonService );
+ DALI_TEST_CHECK(!singletonService);
// Create Application class, should be able to retrieve SingletonService now
TestApplication application;
singletonService = SingletonService::Get();
- DALI_TEST_CHECK( singletonService );
+ DALI_TEST_CHECK(singletonService);
END_TEST;
}
int UtcDaliSingletonServiceRegisterAndGetSingleton(void)
{
- TestApplication application;
- SingletonService singletonService( SingletonService::Get() );
+ TestApplication application;
+ SingletonService singletonService(SingletonService::Get());
// Attempt to register an empty handle
TestHandle handle;
- singletonService.Register( typeid( handle ), handle );
- DALI_TEST_CHECK( !singletonService.GetSingleton( typeid( handle ) ) );
+ singletonService.Register(typeid(handle), handle);
+ DALI_TEST_CHECK(!singletonService.GetSingleton(typeid(handle)));
// Create an actor instance and retrieve, should be valid this time
- handle = TestHandle( new TestObject );
- singletonService.Register( typeid( handle ), handle );
- DALI_TEST_CHECK( singletonService.GetSingleton( typeid( handle ) ) );
+ handle = TestHandle(new TestObject);
+ singletonService.Register(typeid(handle), handle);
+ DALI_TEST_CHECK(singletonService.GetSingleton(typeid(handle)));
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/devel-api/common/stage-devel.h>
#include <dali/integration-api/context-notifier.h>
#include <dali/integration-api/events/key-event-integ.h>
-#include <dali/public-api/events/key-event.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/wheel-event-integ.h>
+#include <dali/public-api/dali-core.h>
+#include <dali/public-api/events/key-event.h>
+#include <stdlib.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
using namespace Dali;
namespace
{
-
const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
// Functor for EventProcessingFinished signal
/**
* @param[in] eventProcessingFinished reference to a boolean variable used to check if signal has been called.
*/
- EventProcessingFinishedFunctor( bool& eventProcessingFinished )
- : mEventProcessingFinished( eventProcessingFinished )
- {}
+ EventProcessingFinishedFunctor(bool& eventProcessingFinished)
+ : mEventProcessingFinished(eventProcessingFinished)
+ {
+ }
void operator()()
{
{
KeyEventGeneratedSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
receivedKeyEvent.Reset();
}
- bool functorCalled;
+ bool functorCalled;
KeyEvent receivedKeyEvent;
};
// Functor that sets the data when called
struct KeyEventGeneratedReceivedFunctor
{
- KeyEventGeneratedReceivedFunctor( KeyEventGeneratedSignalData& data )
- : signalData( data )
- {}
+ KeyEventGeneratedReceivedFunctor(KeyEventGeneratedSignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( const KeyEvent& keyEvent )
+ bool operator()(const KeyEvent& keyEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedKeyEvent = keyEvent;
return true;
{
KeyEventSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
receivedKeyEvent.Reset();
}
- bool functorCalled;
+ bool functorCalled;
KeyEvent receivedKeyEvent;
};
// Functor that sets the data when called
struct KeyEventReceivedFunctor
{
- KeyEventReceivedFunctor( KeyEventSignalData& data ) : signalData( data ) { }
+ KeyEventReceivedFunctor(KeyEventSignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( const KeyEvent& keyEvent )
+ bool operator()(const KeyEvent& keyEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedKeyEvent = keyEvent;
return true;
{
TouchedSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
receivedTouchEvent.Reset();
}
- bool functorCalled;
+ bool functorCalled;
TouchEvent receivedTouchEvent;
};
// Functor that sets the data when touched signal is received
struct TouchFunctor
{
- TouchFunctor( TouchedSignalData& data ) : signalData( data ) { }
+ TouchFunctor(TouchedSignalData& data)
+ : signalData(data)
+ {
+ }
- void operator()( const TouchEvent& touch )
+ void operator()(const TouchEvent& touch)
{
signalData.functorCalled = true;
TouchEvent handle(touch);
{
WheelEventSignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
functorCalled = false;
}
- bool functorCalled;
+ bool functorCalled;
WheelEvent receivedWheelEvent;
};
// Functor that sets the data when wheel-event signal is received
struct WheelEventReceivedFunctor
{
- WheelEventReceivedFunctor( WheelEventSignalData& data ) : signalData( data ) { }
+ WheelEventReceivedFunctor(WheelEventSignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( const WheelEvent& wheelEvent )
+ bool operator()(const WheelEvent& wheelEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedWheelEvent = wheelEvent;
return true;
WheelEventSignalData& signalData;
};
-bool DummyTouchCallback( Actor actor, const TouchEvent& touch )
+bool DummyTouchCallback(Actor actor, const TouchEvent& touch)
{
return true;
}
struct ContextStatusFunctor
{
- ContextStatusFunctor(bool& calledFlag) : mCalledFlag( calledFlag )
+ ContextStatusFunctor(bool& calledFlag)
+ : mCalledFlag(calledFlag)
{
mCalledFlag = false;
}
struct SceneCreatedStatusFunctor
{
- SceneCreatedStatusFunctor(bool& calledFlag) : mCalledFlag( calledFlag )
+ SceneCreatedStatusFunctor(bool& calledFlag)
+ : mCalledFlag(calledFlag)
{
mCalledFlag = false;
}
struct ActorCreatedFunctor
{
- ActorCreatedFunctor( bool& signalReceived )
- : mSignalVerified( signalReceived )
+ ActorCreatedFunctor(bool& signalReceived)
+ : mSignalVerified(signalReceived)
{
}
- void operator()( BaseHandle object )
+ void operator()(BaseHandle object)
{
- tet_infoline( "Verifying TestActorCallback()" );
- Actor actor = Actor::DownCast( object );
- if( actor )
+ tet_infoline("Verifying TestActorCallback()");
+ Actor actor = Actor::DownCast(object);
+ if(actor)
{
mSignalVerified = true;
}
bool& mSignalVerified;
};
-void GenerateTouch( TestApplication& application, PointState::Type state, const Vector2& screenPosition )
+void GenerateTouch(TestApplication& application, PointState::Type state, const Vector2& screenPosition)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- touchEvent.points.push_back( point );
- application.ProcessEvent( touchEvent );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ touchEvent.points.push_back(point);
+ application.ProcessEvent(touchEvent);
}
} // unnamed namespace
-
int UtcDaliStageDefaultConstructorP(void)
{
TestApplication application;
- Stage stage;
+ Stage stage;
- DALI_TEST_CHECK( !stage );
+ DALI_TEST_CHECK(!stage);
END_TEST;
}
int UtcDaliStageDestructorP(void)
{
TestApplication application;
- Stage* stage = new Stage();
+ Stage* stage = new Stage();
delete stage;
stage = NULL;
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
int UtcDaliStageGetCurrentP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- DALI_TEST_CHECK( stage );
+ DALI_TEST_CHECK(stage);
END_TEST;
}
{
Stage stage = Stage::GetCurrent();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "stage && \"Stage doesn't exist\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "stage && \"Stage doesn't exist\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
Stage::GetCurrent();
- DALI_TEST_CHECK( Stage::IsInstalled() );
+ DALI_TEST_CHECK(Stage::IsInstalled());
END_TEST;
}
int UtcDaliStageIsInstalledN(void)
{
- DALI_TEST_CHECK( !Stage::IsInstalled() );
+ DALI_TEST_CHECK(!Stage::IsInstalled());
END_TEST;
}
int UtcDaliStageCopyConstructorP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- Stage copyStage( stage );
+ Stage copyStage(stage);
- DALI_TEST_CHECK( copyStage );
- DALI_TEST_CHECK( copyStage.GetRootLayer() == stage.GetRootLayer() );
+ DALI_TEST_CHECK(copyStage);
+ DALI_TEST_CHECK(copyStage.GetRootLayer() == stage.GetRootLayer());
END_TEST;
}
int UtcDaliStageAssignmentOperatorP(void)
{
TestApplication application;
- const Stage stage = Stage::GetCurrent();
+ const Stage stage = Stage::GetCurrent();
Stage copyStage = stage;
- DALI_TEST_CHECK( copyStage );
- DALI_TEST_CHECK( copyStage.GetRootLayer() == stage.GetRootLayer() );
+ DALI_TEST_CHECK(copyStage);
+ DALI_TEST_CHECK(copyStage.GetRootLayer() == stage.GetRootLayer());
END_TEST;
}
Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
- stage.Add( actor );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ stage.Add(actor);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
END_TEST;
}
bool asserted = false;
try
{
- stage.Add( actor );
+ stage.Add(actor);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "actor && \"Actor handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "actor && \"Actor handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
- stage.Add( actor );
- DALI_TEST_CHECK( actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ stage.Add(actor);
+ DALI_TEST_CHECK(actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
stage.Remove(actor);
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
END_TEST;
}
try
{
// Actor is not valid, confirm a removal attempt does assert.
- stage.Remove( actor );
+ stage.Remove(actor);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "actor && \"Actor handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "actor && \"Actor handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
Stage stage = Stage::GetCurrent();
Actor actor = Actor::New();
- DALI_TEST_CHECK( !actor.GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE ) );
+ DALI_TEST_CHECK(!actor.GetProperty<bool>(Actor::Property::CONNECTED_TO_SCENE));
bool asserted = false;
try
{
// Actor is not on stage, confirm a removal attempt does not assert / segfault.
- stage.Remove( actor );
+ stage.Remove(actor);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
asserted = true;
}
- DALI_TEST_CHECK( !asserted );
+ DALI_TEST_CHECK(!asserted);
END_TEST;
}
Stage stage = Stage::GetCurrent();
// Initially we have a default layer
- DALI_TEST_EQUALS( stage.GetLayerCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
// Check we cannot remove the root layer from the stage.
- Layer layer = stage.GetRootLayer();
- bool asserted = true;
+ Layer layer = stage.GetRootLayer();
+ bool asserted = true;
try
{
- stage.Remove( layer );
+ stage.Remove(layer);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "this != &child && \"Cannot remove actor from itself\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "this != &child && \"Cannot remove actor from itself\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
- DALI_TEST_EQUALS( stage.GetLayerCount(), 1u, TEST_LOCATION );
+ DALI_TEST_CHECK(asserted);
+ DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
END_TEST;
}
Vector2 size = stage.GetSize();
- DALI_TEST_EQUALS( size.width, static_cast<float>( TestApplication::DEFAULT_SURFACE_WIDTH ), TEST_LOCATION );
- DALI_TEST_EQUALS( size.height, static_cast<float>( TestApplication::DEFAULT_SURFACE_HEIGHT ), TEST_LOCATION );
+ DALI_TEST_EQUALS(size.width, static_cast<float>(TestApplication::DEFAULT_SURFACE_WIDTH), TEST_LOCATION);
+ DALI_TEST_EQUALS(size.height, static_cast<float>(TestApplication::DEFAULT_SURFACE_HEIGHT), TEST_LOCATION);
END_TEST;
}
Stage stage;
- bool asserted = false;
+ bool asserted = false;
Vector2 size;
try
{
size = stage.GetSize();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "stage && \"Stage handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
// Test the default DPI.
Vector2 dpi = stage.GetDpi();
- DALI_TEST_EQUALS( dpi.x, static_cast<float>( TestApplication::DEFAULT_HORIZONTAL_DPI ), TEST_LOCATION );
- DALI_TEST_EQUALS( dpi.y, static_cast<float>( TestApplication::DEFAULT_VERTICAL_DPI ), TEST_LOCATION );
+ DALI_TEST_EQUALS(dpi.x, static_cast<float>(TestApplication::DEFAULT_HORIZONTAL_DPI), TEST_LOCATION);
+ DALI_TEST_EQUALS(dpi.y, static_cast<float>(TestApplication::DEFAULT_VERTICAL_DPI), TEST_LOCATION);
END_TEST;
}
// Test that setting core DPI explicitly also sets up the Stage's DPI.
Dali::Integration::Scene scene = application.GetScene();
- scene.SetDpi( Vector2(200.0f, 180.0f) );
+ scene.SetDpi(Vector2(200.0f, 180.0f));
- Stage stage = Stage::GetCurrent();
- Vector2 dpi = stage.GetDpi();
- DALI_TEST_EQUALS( dpi.x, 200.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( dpi.y, 180.0f, TEST_LOCATION );
+ Stage stage = Stage::GetCurrent();
+ Vector2 dpi = stage.GetDpi();
+ DALI_TEST_EQUALS(dpi.x, 200.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(dpi.y, 180.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliStageGetDpiP3(void)
{
- TestApplication application( 480, 800, 72, 120 ); // Initializes core DPI with specific values
+ TestApplication application(480, 800, 72, 120); // Initializes core DPI with specific values
Stage stage = Stage::GetCurrent();
// Test that setting core DPI explicitly also sets up the Stage's DPI.
Vector2 dpi = stage.GetDpi();
- DALI_TEST_EQUALS( dpi.x, 72.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( dpi.y, 120.0f, TEST_LOCATION) ;
+ DALI_TEST_EQUALS(dpi.x, 72.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(dpi.y, 120.0f, TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Initializes core DPI to default values
- Stage stage = Stage::GetCurrent();
- Vector2 dpi = stage.GetDpi();
+ Stage stage = Stage::GetCurrent();
+ Vector2 dpi = stage.GetDpi();
- DALI_TEST_EQUALS( dpi.x, 220.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( dpi.y, 217.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(dpi.x, 220.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(dpi.y, 217.0f, TEST_LOCATION);
END_TEST;
}
Stage stage = Stage::GetCurrent();
// Initially we have a default layer
- DALI_TEST_EQUALS( stage.GetLayerCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
Layer layer = Layer::New();
- stage.Add( layer );
+ stage.Add(layer);
- DALI_TEST_EQUALS( stage.GetLayerCount(), 2u, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetLayerCount(), 2u, TEST_LOCATION);
END_TEST;
}
Stage stage = Stage::GetCurrent();
// Initially we have a default layer
- DALI_TEST_EQUALS( stage.GetLayerCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
Layer layer = Layer::New();
- stage.Remove( layer );
+ stage.Remove(layer);
// Still have 1 layer.
- DALI_TEST_EQUALS( stage.GetLayerCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetLayerCount(), 1u, TEST_LOCATION);
END_TEST;
}
Stage stage = Stage::GetCurrent();
- Layer rootLayer = stage.GetLayer( 0 );
- DALI_TEST_CHECK( rootLayer );
+ Layer rootLayer = stage.GetLayer(0);
+ DALI_TEST_CHECK(rootLayer);
Layer layer = Layer::New();
- stage.Add( layer );
+ stage.Add(layer);
- Layer sameLayer = stage.GetLayer( 1 );
- DALI_TEST_CHECK( layer == sameLayer );
+ Layer sameLayer = stage.GetLayer(1);
+ DALI_TEST_CHECK(layer == sameLayer);
END_TEST;
}
try
{
// Try to get a layer that doesn't exist (note: 0 is the root layer).
- Layer layer = stage.GetLayer( 1 );
+ Layer layer = stage.GetLayer(1);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "depth < mLayers.size()", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "depth < mLayers.size()", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
Stage stage = Stage::GetCurrent();
- Layer layer = stage.GetLayer( 0 );
- DALI_TEST_CHECK( layer );
+ Layer layer = stage.GetLayer(0);
+ DALI_TEST_CHECK(layer);
// Check that GetRootLayer() correctly retreived layer 0.
- DALI_TEST_CHECK( stage.GetRootLayer() == layer );
+ DALI_TEST_CHECK(stage.GetRootLayer() == layer);
END_TEST;
}
Stage stage = Stage::GetCurrent();
- Layer rootLayer = stage.GetLayer( 0 );
- DALI_TEST_CHECK( rootLayer );
- DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
+ Layer rootLayer = stage.GetLayer(0);
+ DALI_TEST_CHECK(rootLayer);
+ DALI_TEST_CHECK(stage.GetRootLayer() == rootLayer);
// Create a new layer and attempt to lower it below the root layer.
Layer layer = Layer::New();
- stage.Add( layer );
+ stage.Add(layer);
layer.LowerToBottom();
// Check that GetRootLayer still retrieves the same original layer.
- DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
+ DALI_TEST_CHECK(stage.GetRootLayer() == rootLayer);
// Check modifying the root layer is also blocked.
rootLayer.RaiseToTop();
- DALI_TEST_CHECK( stage.GetRootLayer() == rootLayer );
+ DALI_TEST_CHECK(stage.GetRootLayer() == rootLayer);
END_TEST;
}
Stage stage = Stage::GetCurrent();
- Vector4 testColor( 0.1f, 0.2f, 0.3f, 1.0f );
- stage.SetBackgroundColor( testColor );
+ Vector4 testColor(0.1f, 0.2f, 0.3f, 1.0f);
+ stage.SetBackgroundColor(testColor);
- DALI_TEST_EQUALS( testColor, stage.GetBackgroundColor(), TEST_LOCATION );
+ DALI_TEST_EQUALS(testColor, stage.GetBackgroundColor(), TEST_LOCATION);
END_TEST;
}
Stage stage = Stage::GetCurrent();
- DALI_TEST_EQUALS( DEFAULT_BACKGROUND_COLOR, stage.GetBackgroundColor(), TEST_LOCATION );
+ DALI_TEST_EQUALS(DEFAULT_BACKGROUND_COLOR, stage.GetBackgroundColor(), TEST_LOCATION);
END_TEST;
}
Stage stage = Stage::GetCurrent();
// Run core until it wants to sleep
- bool keepUpdating( true );
- while ( keepUpdating )
+ bool keepUpdating(true);
+ while(keepUpdating)
{
application.SendNotification();
- keepUpdating = application.Render( 1000.0f /*1 second*/ );
+ keepUpdating = application.Render(1000.0f /*1 second*/);
}
// Force rendering for the next 5 seconds
- stage.KeepRendering( 5.0f );
+ stage.KeepRendering(5.0f);
application.SendNotification();
// Test that core wants to sleep after 10 seconds
- keepUpdating = application.Render( 1000.0f /*1 second*/ );
- DALI_TEST_CHECK( keepUpdating );
- keepUpdating = application.Render( 1000.0f /*2 seconds*/ );
- DALI_TEST_CHECK( keepUpdating );
- keepUpdating = application.Render( 1000.0f /*3 seconds*/ );
- DALI_TEST_CHECK( keepUpdating );
- keepUpdating = application.Render( 1000.0f /*4 seconds*/ );
- DALI_TEST_CHECK( keepUpdating );
- keepUpdating = application.Render( 1000.0f /*5 seconds*/ );
- DALI_TEST_CHECK( !keepUpdating );
+ keepUpdating = application.Render(1000.0f /*1 second*/);
+ DALI_TEST_CHECK(keepUpdating);
+ keepUpdating = application.Render(1000.0f /*2 seconds*/);
+ DALI_TEST_CHECK(keepUpdating);
+ keepUpdating = application.Render(1000.0f /*3 seconds*/);
+ DALI_TEST_CHECK(keepUpdating);
+ keepUpdating = application.Render(1000.0f /*4 seconds*/);
+ DALI_TEST_CHECK(keepUpdating);
+ keepUpdating = application.Render(1000.0f /*5 seconds*/);
+ DALI_TEST_CHECK(!keepUpdating);
END_TEST;
}
Stage stage = Stage::GetCurrent();
// Run core until it wants to sleep
- bool keepUpdating( true );
- while ( keepUpdating )
+ bool keepUpdating(true);
+ while(keepUpdating)
{
application.SendNotification();
- keepUpdating = application.Render( 1000.0f /*1 second*/ );
+ keepUpdating = application.Render(1000.0f /*1 second*/);
}
// Force rendering for the next 5 seconds
- stage.KeepRendering( -1.0f );
+ stage.KeepRendering(-1.0f);
application.SendNotification();
// Test that core wants to sleep after 10 seconds
- keepUpdating = application.Render( 1000.0f /*1 second*/ );
- DALI_TEST_CHECK( !keepUpdating );
+ keepUpdating = application.Render(1000.0f /*1 second*/);
+ DALI_TEST_CHECK(!keepUpdating);
END_TEST;
}
int UtcDaliStageEventProcessingFinishedP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- bool eventProcessingFinished = false;
- EventProcessingFinishedFunctor functor( eventProcessingFinished );
- stage.EventProcessingFinishedSignal().Connect( &application, functor );
+ bool eventProcessingFinished = false;
+ EventProcessingFinishedFunctor functor(eventProcessingFinished);
+ stage.EventProcessingFinishedSignal().Connect(&application, functor);
- Actor actor( Actor::New() );
- stage.Add( actor );
+ Actor actor(Actor::New());
+ stage.Add(actor);
application.SendNotification();
application.Render();
- DALI_TEST_CHECK( eventProcessingFinished );
+ DALI_TEST_CHECK(eventProcessingFinished);
END_TEST;
}
int UtcDaliStageEventProcessingFinishedN(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- bool eventProcessingFinished = false;
- EventProcessingFinishedFunctor functor( eventProcessingFinished );
- stage.EventProcessingFinishedSignal().Connect( &application, functor );
+ bool eventProcessingFinished = false;
+ EventProcessingFinishedFunctor functor(eventProcessingFinished);
+ stage.EventProcessingFinishedSignal().Connect(&application, functor);
- Actor actor( Actor::New() );
- stage.Add( actor );
+ Actor actor(Actor::New());
+ stage.Add(actor);
// Do not complete event processing and confirm the signal has not been emitted.
- DALI_TEST_CHECK( !eventProcessingFinished );
+ DALI_TEST_CHECK(!eventProcessingFinished);
END_TEST;
}
int UtcDaliStageKeyEventGeneratedSignalP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- KeyEventGeneratedSignalData data;
- KeyEventGeneratedReceivedFunctor functor( data );
- DevelStage::KeyEventGeneratedSignal( stage ).Connect( &application, functor );
+ KeyEventGeneratedSignalData data;
+ KeyEventGeneratedReceivedFunctor functor(data);
+ DevelStage::KeyEventGeneratedSignal(stage).Connect(&application, functor);
- KeyEventGeneratedSignalData data2;
- KeyEventGeneratedReceivedFunctor functor2( data2 );
- GetImplementation( stage ).ConnectSignal( &application, "keyEventGenerated", functor2 );
+ KeyEventGeneratedSignalData data2;
+ KeyEventGeneratedReceivedFunctor functor2(data2);
+ GetImplementation(stage).ConnectSignal(&application, "keyEventGenerated", functor2);
- Integration::KeyEvent event( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event );
+ Integration::KeyEvent event("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event2( "i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event2 );
+ Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event2);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event3( "a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event3 );
+ Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event3);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event4( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event4 );
+ Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event4);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
END_TEST;
}
int UtcDaliStageSignalKeyEventP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- KeyEventSignalData data;
- KeyEventReceivedFunctor functor( data );
- stage.KeyEventSignal().Connect( &application, functor );
+ KeyEventSignalData data;
+ KeyEventReceivedFunctor functor(data);
+ stage.KeyEventSignal().Connect(&application, functor);
- Integration::KeyEvent event( "i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event );
+ Integration::KeyEvent event("i", "", "i", 0, 0, 0, Integration::KeyEvent::DOWN, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event2( "i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event2 );
+ Integration::KeyEvent event2("i", "", "i", 0, 0, 0, Integration::KeyEvent::UP, "i", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event2);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event2.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event2.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event2.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event2.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event2.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event2.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event2.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event2.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event3( "a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event3 );
+ Integration::KeyEvent event3("a", "", "a", 0, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event3);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event3.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event3.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event3.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event3.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event3.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event3.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event3.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event3.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
data.Reset();
- Integration::KeyEvent event4( "a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE );
- application.ProcessEvent( event4 );
+ Integration::KeyEvent event4("a", "", "a", 0, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE);
+ application.ProcessEvent(event4);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( event4.keyModifier == data.receivedKeyEvent.GetKeyModifier() );
- DALI_TEST_CHECK( event4.keyName == data.receivedKeyEvent.GetKeyName() );
- DALI_TEST_CHECK( event4.keyString == data.receivedKeyEvent.GetKeyString() );
- DALI_TEST_CHECK( event4.state == static_cast<Integration::KeyEvent::State>( data.receivedKeyEvent.GetState() ) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(event4.keyModifier == data.receivedKeyEvent.GetKeyModifier());
+ DALI_TEST_CHECK(event4.keyName == data.receivedKeyEvent.GetKeyName());
+ DALI_TEST_CHECK(event4.keyString == data.receivedKeyEvent.GetKeyString());
+ DALI_TEST_CHECK(event4.state == static_cast<Integration::KeyEvent::State>(data.receivedKeyEvent.GetState()));
END_TEST;
}
int UtcDaliStageSignalKeyEventN(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- KeyEventSignalData data;
- KeyEventReceivedFunctor functor( data );
- stage.KeyEventSignal().Connect( &application, functor );
+ KeyEventSignalData data;
+ KeyEventReceivedFunctor functor(data);
+ stage.KeyEventSignal().Connect(&application, functor);
// Check that a non-pressed key events data is not modified.
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
int UtcDaliStageTouchedSignalP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
TouchedSignalData data;
- TouchFunctor functor( data );
- stage.TouchedSignal().Connect( &application, functor );
+ TouchFunctor functor(data);
+ stage.TouchedSignal().Connect(&application, functor);
// Render and notify.
application.SendNotification();
// Basic test: No actors, single touch (down then up).
{
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
- GenerateTouch( application, PointState::UP, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::UP, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
// Add an actor to the scene.
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.TouchedSignal().Connect( &DummyTouchCallback );
- stage.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.TouchedSignal().Connect(&DummyTouchCallback);
+ stage.Add(actor);
// Render and notify.
application.SendNotification();
// Actor on scene, single touch, down in actor, motion, then up outside actor.
{
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0));
data.Reset();
- GenerateTouch( application, PointState::MOTION, Vector2( 150.0f, 10.0f ) ); // Some motion
+ GenerateTouch(application, PointState::MOTION, Vector2(150.0f, 10.0f)); // Some motion
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
- GenerateTouch( application, PointState::UP, Vector2( 150.0f, 10.0f ) ); // Some motion
+ GenerateTouch(application, PointState::UP, Vector2(150.0f, 10.0f)); // Some motion
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
// Multiple touch. Should only receive a touch on first down and last up.
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
+ Integration::Point point;
// 1st point
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 10.0f, 10.0f ) );
- touchEvent.points.push_back( point );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(10.0f, 10.0f));
+ touchEvent.points.push_back(point);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
data.Reset();
// 2nd point
- touchEvent.points[0].SetState( PointState::STATIONARY );
- point.SetDeviceId( 1 );
- point.SetScreenPosition( Vector2( 50.0f, 50.0f ) );
- touchEvent.points.push_back( point );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( (bool)data.receivedTouchEvent, false, TEST_LOCATION );
+ touchEvent.points[0].SetState(PointState::STATIONARY);
+ point.SetDeviceId(1);
+ point.SetScreenPosition(Vector2(50.0f, 50.0f));
+ touchEvent.points.push_back(point);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS((bool)data.receivedTouchEvent, false, TEST_LOCATION);
data.Reset();
// Primary point is up
- touchEvent.points[0].SetState( PointState::UP );
- touchEvent.points[1].SetState( PointState::STATIONARY );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( (bool)data.receivedTouchEvent, false, TEST_LOCATION );
+ touchEvent.points[0].SetState(PointState::UP);
+ touchEvent.points[1].SetState(PointState::STATIONARY);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS((bool)data.receivedTouchEvent, false, TEST_LOCATION);
data.Reset();
// Remove 1st point now, 2nd point is now in motion
- touchEvent.points.erase( touchEvent.points.begin() );
- touchEvent.points[0].SetState( PointState::MOTION );
- touchEvent.points[0].SetScreenPosition( Vector2( 150.0f, 50.0f ) );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( (bool)data.receivedTouchEvent, false, TEST_LOCATION );
+ touchEvent.points.erase(touchEvent.points.begin());
+ touchEvent.points[0].SetState(PointState::MOTION);
+ touchEvent.points[0].SetScreenPosition(Vector2(150.0f, 50.0f));
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS((bool)data.receivedTouchEvent, false, TEST_LOCATION);
data.Reset();
// Final point Up
- touchEvent.points[0].SetState( PointState::UP );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+ touchEvent.points[0].SetState(PointState::UP);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
data.Reset();
}
END_TEST;
int UtcDaliStageTouchedSignalN(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
TouchedSignalData data;
- TouchFunctor functor( data );
- stage.TouchedSignal().Connect( &application, functor );
+ TouchFunctor functor(data);
+ stage.TouchedSignal().Connect(&application, functor);
// Render and notify.
application.SendNotification();
application.Render();
// Confirm functor not called before there has been any touch event.
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// No actors, single touch, down, motion then up.
{
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
// Confirm there is no signal when the touchpoint is only moved.
- GenerateTouch( application, PointState::MOTION, Vector2( 1200.0f, 10.0f ) ); // Some motion
+ GenerateTouch(application, PointState::MOTION, Vector2(1200.0f, 10.0f)); // Some motion
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Confirm a following up event generates a signal.
- GenerateTouch( application, PointState::UP, Vector2( 1200.0f, 10.0f ) );
+ GenerateTouch(application, PointState::UP, Vector2(1200.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
data.Reset();
}
// Add an actor to the scene.
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
- actor.TouchedSignal().Connect( &DummyTouchCallback );
- stage.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
+ actor.TouchedSignal().Connect(&DummyTouchCallback);
+ stage.Add(actor);
// Render and notify.
application.SendNotification();
// Actor on scene. Interrupted before down and interrupted after down.
{
- GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
data.Reset();
- GenerateTouch( application, PointState::DOWN, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::DOWN, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetHitActor(0) == actor );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::DOWN );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetHitActor(0) == actor);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::DOWN);
data.Reset();
- GenerateTouch( application, PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) );
+ GenerateTouch(application, PointState::INTERRUPTED, Vector2(10.0f, 10.0f));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetPointCount() != 0u );
- DALI_TEST_CHECK( !data.receivedTouchEvent.GetHitActor(0) );
- DALI_TEST_CHECK( data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetPointCount() != 0u);
+ DALI_TEST_CHECK(!data.receivedTouchEvent.GetHitActor(0));
+ DALI_TEST_CHECK(data.receivedTouchEvent.GetState(0) == PointState::INTERRUPTED);
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetPointCount(), 1u, TEST_LOCATION);
// Check that getting info about a non-existent point causes an assert.
- DALI_TEST_EQUALS( data.receivedTouchEvent.GetState( 1 ), PointState::FINISHED, TEST_LOCATION );
+ DALI_TEST_EQUALS(data.receivedTouchEvent.GetState(1), PointState::FINISHED, TEST_LOCATION);
data.Reset();
}
int UtcDaliStageSignalWheelEventP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- WheelEventSignalData data;
- WheelEventReceivedFunctor functor( data );
- stage.WheelEventSignal().Connect( &application, functor );
+ WheelEventSignalData data;
+ WheelEventReceivedFunctor functor(data);
+ stage.WheelEventSignal().Connect(&application, functor);
- Integration::WheelEvent event( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), 1, 1000u );
- application.ProcessEvent( event );
+ Integration::WheelEvent event(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), 1, 1000u);
+ application.ProcessEvent(event);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event.type) == data.receivedWheelEvent.GetType() );
- DALI_TEST_CHECK( event.direction == data.receivedWheelEvent.GetDirection() );
- DALI_TEST_CHECK( event.modifiers == data.receivedWheelEvent.GetModifiers() );
- DALI_TEST_CHECK( event.point == data.receivedWheelEvent.GetPoint() );
- DALI_TEST_CHECK( event.delta == data.receivedWheelEvent.GetDelta() );
- DALI_TEST_CHECK( event.timeStamp == data.receivedWheelEvent.GetTime() );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event.type) == data.receivedWheelEvent.GetType());
+ DALI_TEST_CHECK(event.direction == data.receivedWheelEvent.GetDirection());
+ DALI_TEST_CHECK(event.modifiers == data.receivedWheelEvent.GetModifiers());
+ DALI_TEST_CHECK(event.point == data.receivedWheelEvent.GetPoint());
+ DALI_TEST_CHECK(event.delta == data.receivedWheelEvent.GetDelta());
+ DALI_TEST_CHECK(event.timeStamp == data.receivedWheelEvent.GetTime());
data.Reset();
- Integration::WheelEvent event2( Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2( 0.0f, 0.0f ), -1, 1000u );
- application.ProcessEvent( event2 );
+ Integration::WheelEvent event2(Integration::WheelEvent::CUSTOM_WHEEL, 0, 0u, Vector2(0.0f, 0.0f), -1, 1000u);
+ application.ProcessEvent(event2);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( static_cast< WheelEvent::Type >(event2.type) == data.receivedWheelEvent.GetType() );
- DALI_TEST_CHECK( event2.direction == data.receivedWheelEvent.GetDirection() );
- DALI_TEST_CHECK( event2.modifiers == data.receivedWheelEvent.GetModifiers() );
- DALI_TEST_CHECK( event2.point == data.receivedWheelEvent.GetPoint() );
- DALI_TEST_CHECK( event2.delta == data.receivedWheelEvent.GetDelta() );
- DALI_TEST_CHECK( event2.timeStamp == data.receivedWheelEvent.GetTime() );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(static_cast<WheelEvent::Type>(event2.type) == data.receivedWheelEvent.GetType());
+ DALI_TEST_CHECK(event2.direction == data.receivedWheelEvent.GetDirection());
+ DALI_TEST_CHECK(event2.modifiers == data.receivedWheelEvent.GetModifiers());
+ DALI_TEST_CHECK(event2.point == data.receivedWheelEvent.GetPoint());
+ DALI_TEST_CHECK(event2.delta == data.receivedWheelEvent.GetDelta());
+ DALI_TEST_CHECK(event2.timeStamp == data.receivedWheelEvent.GetTime());
END_TEST;
}
int UtcDaliStageContextLostSignalP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- bool contextLost = false;
- ContextStatusFunctor contextLostFunctor( contextLost );
- stage.ContextLostSignal().Connect( &application, contextLostFunctor );
+ bool contextLost = false;
+ ContextStatusFunctor contextLostFunctor(contextLost);
+ stage.ContextLostSignal().Connect(&application, contextLostFunctor);
Integration::ContextNotifierInterface* notifier = application.GetCore().GetContextNotifier();
notifier->NotifyContextLost();
- DALI_TEST_EQUALS( contextLost, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(contextLost, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliStageContextLostSignalN(void)
{
TestApplication application;
- Stage stage;
+ Stage stage;
// Check that connecting to the signal with a bad stage instance causes an assert.
- bool asserted = false;
- bool contextLost = false;
- ContextStatusFunctor contextLostFunctor( contextLost );
+ bool asserted = false;
+ bool contextLost = false;
+ ContextStatusFunctor contextLostFunctor(contextLost);
try
{
- stage.ContextLostSignal().Connect( &application, contextLostFunctor );
+ stage.ContextLostSignal().Connect(&application, contextLostFunctor);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "stage && \"Stage handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliStageContextRegainedSignalP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- bool contextRegained = false;
- ContextStatusFunctor contextRegainedFunctor( contextRegained );
- stage.ContextRegainedSignal().Connect( &application, contextRegainedFunctor );
+ bool contextRegained = false;
+ ContextStatusFunctor contextRegainedFunctor(contextRegained);
+ stage.ContextRegainedSignal().Connect(&application, contextRegainedFunctor);
Integration::ContextNotifierInterface* notifier = application.GetCore().GetContextNotifier();
notifier->NotifyContextLost();
notifier->NotifyContextRegained();
- DALI_TEST_EQUALS( contextRegained, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(contextRegained, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliStageContextRegainedSignalN(void)
{
TestApplication application;
- Stage stage;
+ Stage stage;
// Check that connecting to the signal with a bad stage instance causes an assert.
- bool asserted = false;
- bool contextRegained = false;
- ContextStatusFunctor contextRegainedFunctor( contextRegained );
+ bool asserted = false;
+ bool contextRegained = false;
+ ContextStatusFunctor contextRegainedFunctor(contextRegained);
try
{
- stage.ContextRegainedSignal().Connect( &application, contextRegainedFunctor );
+ stage.ContextRegainedSignal().Connect(&application, contextRegainedFunctor);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "stage && \"Stage handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliStageSceneCreatedSignalP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- bool signalCalled = false;
- SceneCreatedStatusFunctor sceneCreatedFunctor( signalCalled );
- stage.SceneCreatedSignal().Connect( &application, sceneCreatedFunctor );
+ bool signalCalled = false;
+ SceneCreatedStatusFunctor sceneCreatedFunctor(signalCalled);
+ stage.SceneCreatedSignal().Connect(&application, sceneCreatedFunctor);
Integration::Core& core = application.GetCore();
core.SceneCreated();
- DALI_TEST_EQUALS( signalCalled, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(signalCalled, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliStageSceneCreatedSignalN(void)
{
TestApplication application;
- Stage stage;
+ Stage stage;
// Check that connecting to the signal with a bad stage instance causes an assert.
- bool asserted = false;
- bool signalCalled = false;
- SceneCreatedStatusFunctor sceneCreatedFunctor( signalCalled );
+ bool asserted = false;
+ bool signalCalled = false;
+ SceneCreatedStatusFunctor sceneCreatedFunctor(signalCalled);
try
{
- stage.SceneCreatedSignal().Connect( &application, sceneCreatedFunctor );
+ stage.SceneCreatedSignal().Connect(&application, sceneCreatedFunctor);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "stage && \"Stage handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliStageGetRenderTaskListP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
// Check we get a valid instance.
const RenderTaskList& tasks = stage.GetRenderTaskList();
// There should be 1 task by default.
- DALI_TEST_EQUALS( tasks.GetTaskCount(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(tasks.GetTaskCount(), 1u, TEST_LOCATION);
// RenderTaskList has it's own UTC tests.
// But we can confirm that GetRenderTaskList in Stage retrieves the same RenderTaskList each time.
RenderTask newTask = stage.GetRenderTaskList().CreateTask();
- DALI_TEST_EQUALS( stage.GetRenderTaskList().GetTask( 1 ), newTask, TEST_LOCATION );
+ DALI_TEST_EQUALS(stage.GetRenderTaskList().GetTask(1), newTask, TEST_LOCATION);
END_TEST;
}
int UtcDaliStageGetRenderTaskListN(void)
{
TestApplication application;
- Stage stage;
+ Stage stage;
// Check that getting the render task list with a bad stage instance causes an assert.
bool asserted = false;
{
stage.GetRenderTaskList();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "stage && \"Stage handle is empty\"", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "stage && \"Stage handle is empty\"", TEST_LOCATION);
asserted = true;
}
- DALI_TEST_CHECK( asserted );
+ DALI_TEST_CHECK(asserted);
END_TEST;
}
int UtcDaliStageGetObjectRegistryP(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
ObjectRegistry objectRegistry = stage.GetObjectRegistry();
// Object registry tests are covered in their own module.
// However we want a basic test to confirm the returned registry is valid and works.
- bool verified = false;
- ActorCreatedFunctor test( verified );
- objectRegistry.ObjectCreatedSignal().Connect( &application, test );
+ bool verified = false;
+ ActorCreatedFunctor test(verified);
+ objectRegistry.ObjectCreatedSignal().Connect(&application, test);
Actor actor = Actor::New();
- DALI_TEST_CHECK( test.mSignalVerified );
+ DALI_TEST_CHECK(test.mSignalVerified);
END_TEST;
}
int UtcDaliStageGetObjectRegistryN(void)
{
TestApplication application;
- Stage stage;
+ Stage stage;
// Check that getting the object registry with a bad stage instance DOES NOT cause an assert.
// This is because GetCurrent() is used, always creating a stage if one does not exist.
{
stage.GetObjectRegistry();
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
asserted = true;
}
- DALI_TEST_CHECK( !asserted );
+ DALI_TEST_CHECK(!asserted);
END_TEST;
}
int UtcDaliStageOperatorAssign(void)
{
TestApplication application;
- Stage stage;
- DALI_TEST_CHECK( !stage );
+ Stage stage;
+ DALI_TEST_CHECK(!stage);
stage = Stage::GetCurrent();
- DALI_TEST_CHECK( stage );
+ DALI_TEST_CHECK(stage);
END_TEST;
}
int UtcDaliStageRenderingBehavior(void)
{
TestApplication application;
- Stage stage = Stage::GetCurrent();
+ Stage stage = Stage::GetCurrent();
- tet_infoline( "Check default rendering behavior is only if required" );
- DALI_TEST_CHECK( DevelStage::GetRenderingBehavior( stage ) == DevelStage::Rendering::IF_REQUIRED );
+ tet_infoline("Check default rendering behavior is only if required");
+ DALI_TEST_CHECK(DevelStage::GetRenderingBehavior(stage) == DevelStage::Rendering::IF_REQUIRED);
- tet_infoline( "No update required with an empty application" );
+ tet_infoline("No update required with an empty application");
application.SendNotification();
- DALI_TEST_CHECK( application.UpdateOnly() == false );
+ DALI_TEST_CHECK(application.UpdateOnly() == false);
application.RenderOnly();
- tet_infoline( "Change to continuous rendering, further updates should be required" );
- DevelStage::SetRenderingBehavior( stage, DevelStage::Rendering::CONTINUOUSLY );
+ tet_infoline("Change to continuous rendering, further updates should be required");
+ DevelStage::SetRenderingBehavior(stage, DevelStage::Rendering::CONTINUOUSLY);
- DALI_TEST_CHECK( DevelStage::GetRenderingBehavior( stage ) == DevelStage::Rendering::CONTINUOUSLY );
+ DALI_TEST_CHECK(DevelStage::GetRenderingBehavior(stage) == DevelStage::Rendering::CONTINUOUSLY);
application.SendNotification();
- DALI_TEST_CHECK( application.UpdateOnly() == true );
+ DALI_TEST_CHECK(application.UpdateOnly() == true);
application.RenderOnly();
application.SendNotification();
- DALI_TEST_CHECK( application.UpdateOnly() == true );
+ DALI_TEST_CHECK(application.UpdateOnly() == true);
application.RenderOnly();
- tet_infoline( "Change to rendering only if required, further updates should NOT be required" );
- DevelStage::SetRenderingBehavior( stage, DevelStage::Rendering::IF_REQUIRED );
+ tet_infoline("Change to rendering only if required, further updates should NOT be required");
+ DevelStage::SetRenderingBehavior(stage, DevelStage::Rendering::IF_REQUIRED);
- DALI_TEST_CHECK( DevelStage::GetRenderingBehavior( stage ) == DevelStage::Rendering::IF_REQUIRED );
+ DALI_TEST_CHECK(DevelStage::GetRenderingBehavior(stage) == DevelStage::Rendering::IF_REQUIRED);
application.SendNotification();
- DALI_TEST_CHECK( application.UpdateOnly() == false );
+ DALI_TEST_CHECK(application.UpdateOnly() == false);
application.RenderOnly();
- tet_infoline( "The next update is not required so TestApplication should print a warning" );
+ tet_infoline("The next update is not required so TestApplication should print a warning");
application.SendNotification();
- DALI_TEST_CHECK( application.UpdateOnly() == false );
+ DALI_TEST_CHECK(application.UpdateOnly() == false);
application.RenderOnly();
END_TEST;
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
#include <test-touch-event-utils.h>
+#include <iostream>
+
using namespace Dali;
void utc_dali_tap_gesture_detector_startup(void)
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
SignalData()
: functorCalled(false),
voidFunctorCalled(false)
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
tappedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
TapGesture receivedGesture;
- Actor tappedActor;
+ Actor tappedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const TapGesture& tap)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = tap;
- signalData.tappedActor = actor;
+ signalData.tappedActor = actor;
}
void operator()()
// Functor that removes the gestured actor from stage
struct UnstageActorFunctor : public GestureReceivedFunctor
{
- UnstageActorFunctor( SignalData& data, Integration::Scene scene )
- : GestureReceivedFunctor( data ),
- scene( scene )
+ UnstageActorFunctor(SignalData& data, Integration::Scene scene)
+ : GestureReceivedFunctor(data),
+ scene(scene)
{
}
void operator()(Actor actor, const TapGesture& tap)
{
- GestureReceivedFunctor::operator()( actor, tap );
- scene.Remove( actor );
+ GestureReceivedFunctor::operator()(actor, tap);
+ scene.Remove(actor);
}
Integration::Scene scene;
{
//For line coverage
unsigned int points = touch.GetPointCount();
- if( points > 0)
+ if(points > 0)
{
tet_printf("Touch Point state = %d\n", touch.GetState(0));
}
}
};
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
-
// Positive test case for a method
int UtcDaliTapGestureDetectorConstructor(void)
{
TapGestureDetector detector = TapGestureDetector::New();
- TapGestureDetector copy( detector );
- DALI_TEST_CHECK( detector );
+ TapGestureDetector copy(detector);
+ DALI_TEST_CHECK(detector);
END_TEST;
}
{
TestApplication application;
- TapGestureDetector detector = TapGestureDetector::New();;
+ TapGestureDetector detector = TapGestureDetector::New();
+ ;
TapGestureDetector assign;
assign = detector;
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(detector);
- DALI_TEST_CHECK( detector == assign );
+ DALI_TEST_CHECK(detector == assign);
END_TEST;
}
DALI_TEST_EQUALS(1u, detector.GetMinimumTapsRequired(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, detector.GetMaximumTapsRequired(), TEST_LOCATION);
- TapGestureDetector detector2 = TapGestureDetector::New( 5u );
+ TapGestureDetector detector2 = TapGestureDetector::New(5u);
DALI_TEST_CHECK(detector2);
DALI_TEST_EQUALS(5u, detector2.GetMinimumTapsRequired(), TEST_LOCATION);
DALI_TEST_EQUALS(5u, detector2.GetMaximumTapsRequired(), TEST_LOCATION);
// Attach an actor and emit a touch event on the actor to ensure complete line coverage
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
TouchEventFunctor touchFunctor;
- actor.TouchedSignal().Connect( &application, touchFunctor );
+ actor.TouchedSignal().Connect(&application, touchFunctor);
Integration::TouchEvent touchEvent(1);
- Integration::Point point;
- point.SetDeviceId( 1 );
- point.SetState( PointState::DOWN );
- point.SetScreenPosition( Vector2( 20.0f, 20.0f ) );
+ Integration::Point point;
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(20.0f, 20.0f));
touchEvent.AddPoint(point);
application.ProcessEvent(touchEvent);
TapGestureDetector detector2 = TapGestureDetector::DownCast(object);
DALI_TEST_CHECK(detector2);
- TapGestureDetector detector3 = DownCast< TapGestureDetector >(object);
+ TapGestureDetector detector3 = DownCast<TapGestureDetector>(object);
DALI_TEST_CHECK(detector3);
- BaseHandle unInitializedObject;
+ BaseHandle unInitializedObject;
TapGestureDetector detector4 = TapGestureDetector::DownCast(unInitializedObject);
DALI_TEST_CHECK(!detector4);
- TapGestureDetector detector5 = DownCast< TapGestureDetector >(unInitializedObject);
+ TapGestureDetector detector5 = DownCast<TapGestureDetector>(unInitializedObject);
DALI_TEST_CHECK(!detector5);
- GestureDetector detector6 = TapGestureDetector::New();
+ GestureDetector detector6 = TapGestureDetector::New();
TapGestureDetector detector7 = TapGestureDetector::DownCast(detector6);
DALI_TEST_CHECK(detector7);
END_TEST;
// Attach an actor and change the required touches
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
try
{
TapGestureDetector detector = TapGestureDetector::New();
- detector.SetMinimumTapsRequired( 7u );
- detector.SetMaximumTapsRequired( 3u );
+ detector.SetMinimumTapsRequired(7u);
+ detector.SetMaximumTapsRequired(3u);
detector.Attach(actor);
- DALI_TEST_CHECK( false ); // Should not get here
+ DALI_TEST_CHECK(false); // Should not get here
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
}
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Do a tap outside actor's area
- TestGenerateTap( application, 112.0f, 112.0f, 100 );
+ TestGenerateTap(application, 112.0f, 112.0f, 100);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Do a tap inside actor's area
- TestGenerateTap( application, 50.0f, 50.0f, 100 );
+ TestGenerateTap(application, 50.0f, 50.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start tap within the actor's area
- TestGenerateTap( application, 20.0f, 20.0f, 100 );
+ TestGenerateTap(application, 20.0f, 20.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(20.0f, 20.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(20.0f, 20.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
// repeat the tap within the actor's area - we should still receive the signal
data.Reset();
- TestGenerateTap( application, 50.0f, 50.0f, 700 );
+ TestGenerateTap(application, 50.0f, 50.0f, 700);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.GetLocalPoint(), 0.1, TEST_LOCATION);
// Detach actor
detector.DetachAll();
// Ensure we are no longer signalled
data.Reset();
- TestGenerateTap( application, 20.0f, 20.0f, 1300 );
+ TestGenerateTap(application, 20.0f, 20.0f, 1300);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- TestGenerateTap( application, 50.0f, 50.0f, 1900 );
+ TestGenerateTap(application, 50.0f, 50.0f, 1900);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
// Actor lifetime is scoped
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
// Start tap within the actor's area
- TestGenerateTap( application, 20.0f, 20.0f, 100 );
+ TestGenerateTap(application, 20.0f, 20.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Remove the actor from stage and reset the data
// Actor should now have been destroyed
data.Reset();
- TestGenerateTap( application, 20.0f, 20.0f, 700 );
+ TestGenerateTap(application, 20.0f, 20.0f, 700);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do tap, only check finished value
- TestGenerateTap( application, 5.0f, 5.0f, 100 );
+ TestGenerateTap(application, 5.0f, 5.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
// Rotate actor again and render
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(180.0f), Vector3::ZAXIS));
application.SendNotification();
application.Render();
// Do tap, should still receive event
data.Reset();
- TestGenerateTap( application, 5.0f, 5.0f, 700 );
+ TestGenerateTap(application, 5.0f, 5.0f, 700);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTaps(), TEST_LOCATION);
DALI_TEST_EQUALS(1u, data.receivedGesture.GetNumberOfTouches(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(5.0f, 5.0f), data.receivedGesture.GetScreenPoint(), 0.1, TEST_LOCATION);
// Rotate actor again and render
- actor.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::YAXIS) );
+ actor.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::YAXIS));
application.SendNotification();
application.Render();
// Do tap, inside the actor's area (area if it is not rotated), Should not receive the event
data.Reset();
- TestGenerateTap( application, 70.0f, 70.0f, 1300 );
+ TestGenerateTap(application, 70.0f, 70.0f, 1300);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
// Set child to completely cover parent.
// Change rotation of child to be different from parent so that we can check if our local coordinate
// conversion of the parent actor is correct.
Actor child = Actor::New();
- child.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- child.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- child.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- child.SetProperty( Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS) );
+ child.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ child.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ child.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ child.SetProperty(Actor::Property::ORIENTATION, Quaternion(Dali::Degree(90.0f), Vector3::ZAXIS));
parent.Add(child);
TouchEventFunctor touchFunctor;
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Do tap - hits child area but parent should still receive it
- TestGenerateTap( application, 50.0f, 50.0f, 100 );
+ TestGenerateTap(application, 50.0f, 50.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, parent == data.tappedActor, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(50.0f, 50.0f), data.receivedGesture.GetScreenPoint(), 0.01f, TEST_LOCATION);
// Do an entire tap, only check finished value
data.Reset();
- TestGenerateTap( application, 51.0f, 51.0f, 700 );
+ TestGenerateTap(application, 51.0f, 51.0f, 700);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, child == data.tappedActor, TEST_LOCATION);
DALI_TEST_EQUALS(Vector2(51.0f, 51.0f), data.receivedGesture.GetScreenPoint(), 0.01f, TEST_LOCATION);
TestApplication application;
Actor first = Actor::New();
- first.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- first.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(first);
Actor second = Actor::New();
- second.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- second.SetProperty( Actor::Property::POSITION_X, 100.0f);
- second.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ second.SetProperty(Actor::Property::POSITION_X, 100.0f);
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(second);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Tap within second actor's area
- TestGenerateTap( application, 120.0f, 10.0f, 100 );
+ TestGenerateTap(application, 120.0f, 10.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.tappedActor, TEST_LOCATION);
// Tap within first actor's area
data.Reset();
- TestGenerateTap( application, 20.0f, 10.0f, 700 );
+ TestGenerateTap(application, 20.0f, 10.0f, 700);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, first == data.tappedActor, TEST_LOCATION);
// second actor shouldn't receive event
data.Reset();
- TestGenerateTap( application, 120.0f, 10.0f, 1300 );
+ TestGenerateTap(application, 120.0f, 10.0f, 1300);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// first actor should continue receiving event
data.Reset();
- TestGenerateTap( application, 20.0f, 10.0f, 1900 );
+ TestGenerateTap(application, 20.0f, 10.0f, 1900);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Tap in actor's area
- TestGenerateTap( application, 50.0f, 10.0f, 100 );
+ TestGenerateTap(application, 50.0f, 10.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
// Actor become invisible - actor should not receive the next pan
- actor.SetProperty( Actor::Property::VISIBLE,false);
+ actor.SetProperty(Actor::Property::VISIBLE, false);
// Render and notify
application.SendNotification();
// Tap in the same area, shouldn't receive event
data.Reset();
- TestGenerateTap( application, 50.0f, 10.0f, 700 );
+ TestGenerateTap(application, 50.0f, 10.0f, 700);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor first = Actor::New();
- first.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- first.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ first.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ first.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(first);
Actor second = Actor::New();
- second.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- second.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- second.SetProperty( Actor::Property::POSITION_X, 100.0f);
+ second.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ second.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ second.SetProperty(Actor::Property::POSITION_X, 100.0f);
first.Add(second);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector firstDetector = TapGestureDetector::New();
// secondDetector is scoped
{
- TapGestureDetector secondDetector = TapGestureDetector::New( 2 );
+ TapGestureDetector secondDetector = TapGestureDetector::New(2);
secondDetector.Attach(second);
secondDetector.DetectedSignal().Connect(&application, functor);
// Tap within second actor's area
- TestGenerateTap( application, 150.0f, 10.0f, 100 );
- TestGenerateTap( application, 150.0f, 10.0f, 200 );
+ TestGenerateTap(application, 150.0f, 10.0f, 100);
+ TestGenerateTap(application, 150.0f, 10.0f, 200);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, second == data.tappedActor, TEST_LOCATION);
// Tap continues as single touch gesture - we should not receive any gesture
data.Reset();
- TestGenerateTap( application, 150.0f, 10.0f, 800 );
+ TestGenerateTap(application, 150.0f, 10.0f, 800);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Single touch tap starts - first actor should be panned
data.Reset();
- TestGenerateTap( application, 50.0f, 10.0f, 1400 );
+ TestGenerateTap(application, 50.0f, 10.0f, 1400);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, first == data.tappedActor, TEST_LOCATION);
// Tap changes to double-touch - we shouldn't receive event
data.Reset();
- TestGenerateTwoPointTap( application, 50.0f, 10.0f, 60.0f, 20.0f, 2000 );
+ TestGenerateTwoPointTap(application, 50.0f, 10.0f, 60.0f, 20.0f, 2000);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to one detector
- SignalData firstData;
+ SignalData firstData;
GestureReceivedFunctor firstFunctor(firstData);
- TapGestureDetector firstDetector = TapGestureDetector::New();
+ TapGestureDetector firstDetector = TapGestureDetector::New();
firstDetector.Attach(actor);
firstDetector.DetectedSignal().Connect(&application, firstFunctor);
// Attach actor to another detector
- SignalData secondData;
+ SignalData secondData;
GestureReceivedFunctor secondFunctor(secondData);
- TapGestureDetector secondDetector = TapGestureDetector::New();
+ TapGestureDetector secondDetector = TapGestureDetector::New();
secondDetector.Attach(actor);
secondDetector.DetectedSignal().Connect(&application, secondFunctor);
// Tap in actor's area - both detector's functors should be called
- TestGenerateTap( application, 50.0f, 10.0f, 100 );
+ TestGenerateTap(application, 50.0f, 10.0f, 100);
DALI_TEST_EQUALS(true, firstData.functorCalled, TEST_LOCATION);
DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
- TapGestureDetector detector = TapGestureDetector::New();
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Gesture possible in actor's area.
- TestStartLongPress( application, 50.0f, 10.0f, 100 );
+ TestStartLongPress(application, 50.0f, 10.0f, 100);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Move actor somewhere else
- actor.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(100.0f, 100.0f));
// Render and notify
application.SendNotification();
application.Render();
// Emit STARTED event, we should not receive the tap.
- TestEndPan( application, Vector2(50.0f, 10.0f), 120 );
+ TestEndPan(application, Vector2(50.0f, 10.0f), 120);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Tap possible in empty area.
- TestStartLongPress( application, 50.0f, 10.0f, 700 );
+ TestStartLongPress(application, 50.0f, 10.0f, 700);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Move actor in to the tap position.
- actor.SetProperty( Actor::Property::POSITION, Vector2( 0.0f, 0.0f ));
+ actor.SetProperty(Actor::Property::POSITION, Vector2(0.0f, 0.0f));
// Render and notify
application.SendNotification();
application.Render();
// Emit STARTED event, we should not receive the tap.
- TestEndPan( application, Vector2(50.0f, 10.0f), 720 );
+ TestEndPan(application, Vector2(50.0f, 10.0f), 720);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
// Normal tap in actor's area for completeness.
- TestGenerateTap( application, 50.0f, 10.0f, 1300 );
+ TestGenerateTap(application, 50.0f, 10.0f, 1300);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- UnstageActorFunctor functor( data, application.GetScene() );
- TapGestureDetector detector = TapGestureDetector::New();
+ SignalData data;
+ UnstageActorFunctor functor(data, application.GetScene());
+ TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
- TestGenerateTap( application, 50.0f, 10.0f, 100 );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- tet_result( TET_PASS ); // If we get here, then the actor removal on signal handler was handled gracefully.
+ TestGenerateTap(application, 50.0f, 10.0f, 100);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ tet_result(TET_PASS); // If we get here, then the actor removal on signal handler was handled gracefully.
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
- TapGestureDetector detector = TapGestureDetector::New();
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit a possible - Down press, as emitted by long press function
- TestStartLongPress( application, 50.0f, 10.0f, 100 );
+ TestStartLongPress(application, 50.0f, 10.0f, 100);
// Detach actor and send a STARTED state, no signal.
detector.DetachAll();
- TestEndPan( application, Vector2(50.0f, 10.0f), 120 );
+ TestEndPan(application, Vector2(50.0f, 10.0f), 120);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
- TapGestureDetector detector = TapGestureDetector::New();
+ SignalData data;
+ GestureReceivedFunctor functor(data);
+ TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Emit a possible - Down press, as emitted by long press function
- TestStartLongPress( application, 50.0f, 10.0f, 100 );
+ TestStartLongPress(application, 50.0f, 10.0f, 100);
// Remove, render and delete actor
application.GetScene().Remove(actor);
actor.Reset();
// Send a STARTED state, no signal - Up motion as provided by end pan function
- TestEndPan( application, Vector2(50.0f, 10.0f), 120 );
+ TestEndPan(application, Vector2(50.0f, 10.0f), 120);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
- TapGestureDetector detector = TapGestureDetector::New();
+ TapGestureDetector detector = TapGestureDetector::New();
detector.Attach(actor);
- detector.DetectedSignal().Connect( &application, functor );
+ detector.DetectedSignal().Connect(&application, functor);
// Add a layer to overlap the actor
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer );
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer);
layer.RaiseToTop();
// Render and notify
application.Render();
// Emit signals, should receive
- TestGenerateTap( application, 50.0f, 50.0f, 100 );
+ TestGenerateTap(application, 50.0f, 50.0f, 100);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Set layer to consume all touch
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
// Render and notify
application.SendNotification();
application.Render();
// Emit the same signals again, should not receive
- TestGenerateTap( application, 50.0f, 50.0f, 700 );
+ TestGenerateTap(application, 50.0f, 50.0f, 700);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
- bool consume = false;
+ bool consume = false;
TouchEventFunctorConsumeSetter touchFunctor(consume);
- actor.TouchedSignal().Connect(&application,touchFunctor);
+ actor.TouchedSignal().Connect(&application, touchFunctor);
// Render and notify
application.SendNotification();
application.Render();
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
TapGestureDetector detector = TapGestureDetector::New();
detector.DetectedSignal().Connect(&application, functor);
// Start gesture within the actor's area, we should receive the gesture as the touch is NOT being consumed
- TestGenerateTap( application, 50.0f, 50.0f );
+ TestGenerateTap(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Another gesture in the same location, this time we will not receive it as touch is being consumed
consume = true;
- TestGenerateTap( application, 50.0f, 50.0f );
+ TestGenerateTap(application, 50.0f, 50.0f);
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Add a detector
- TapGestureDetector detector = TapGestureDetector::New();
- bool functorCalled = false;
- detector.Attach( actor );
+ TapGestureDetector detector = TapGestureDetector::New();
+ bool functorCalled = false;
+ detector.Attach(actor);
detector.DetectedSignal().Connect(
- &application,
- [&detector, &functorCalled](Actor actor, const TapGesture& gesture)
- {
- detector.Detach(actor);
- functorCalled = true;
- });
+ &application,
+ [&detector, &functorCalled](Actor actor, const TapGesture& gesture) {
+ detector.Detach(actor);
+ functorCalled = true;
+ });
// Render and notify
application.SendNotification();
// Try the gesture, should not crash
try
{
- TestGenerateTap( application, 50.0f, 10.0f );
+ TestGenerateTap(application, 50.0f, 10.0f);
- DALI_TEST_CHECK( true ); // No crash, test has passed
+ DALI_TEST_CHECK(true); // No crash, test has passed
DALI_TEST_EQUALS(functorCalled, true, TEST_LOCATION);
}
catch(...)
{
- DALI_TEST_CHECK( false ); // If we crash, the test has failed
+ DALI_TEST_CHECK(false); // If we crash, the test has failed
}
END_TEST;
}
-
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/render-task-list-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+#include <iostream>
using namespace Dali;
///////////////////////////////////////////////////////////////////////////////
namespace
{
-
struct SignalData
{
SignalData()
: functorCalled(false),
voidFunctorCalled(false),
receivedGesture()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
tappedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
TapGesture receivedGesture;
- Actor tappedActor;
+ Actor tappedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, const TapGesture& tap)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = tap;
- signalData.tappedActor = actor;
+ signalData.tappedActor = actor;
}
void operator()()
SignalData& signalData;
};
-
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition, uint32_t time )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-Integration::TouchEvent GenerateDoubleTouch( PointState::Type state, const Vector2& screenPositionA, const Vector2& screenPositionB, uint32_t time )
+Integration::TouchEvent GenerateDoubleTouch(PointState::Type state, const Vector2& screenPositionA, const Vector2& screenPositionB, uint32_t time)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPositionA );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
- point.SetScreenPosition( screenPositionB );
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPositionA);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
+ point.SetScreenPosition(screenPositionB);
+ touchEvent.points.push_back(point);
touchEvent.time = time;
return touchEvent;
}
-
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
-
int UtcDaliTapGestureRecognizerBasic(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerGapTooLong(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 651 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 651));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerInterrupted(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 20.0f, 20.0f ), 175 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(20.0f, 20.0f), 175));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerMoveTooFar(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 50.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(50.0f, 20.0f), 200));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerStartDouble(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), Vector2( 25.0f, 25.0f ), 150 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), Vector2(25.0f, 25.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerEndDouble(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateDoubleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), Vector2( 25.0f, 25.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), Vector2(25.0f, 25.0f), 200));
- application.ProcessEvent( GenerateDoubleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), Vector2( 25.0f, 25.0f ), 200 ) );
+ application.ProcessEvent(GenerateDoubleTouch(PointState::UP, Vector2(20.0f, 20.0f), Vector2(25.0f, 25.0f), 200));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerDoubleTap(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 250 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 250));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 300 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 300));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerDoubleTapMoveTooFar(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 50.0f ), 250 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 50.0f), 250));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 50.0f ), 300 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 50.0f), 300));
application.SendNotification();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 50.0f, 50.0f ), 450 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(50.0f, 50.0f), 450));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 50.0f, 50.0f ), 500 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(50.0f, 50.0f), 500));
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 50.0f, 50.0f ), 550 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(50.0f, 50.0f), 550));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 50.0f, 50.0f ), 600 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(50.0f, 50.0f), 600));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerDoubleTapWaitTooLong(void)
{
TestApplication application;
TapGestureDetector detector = TapGestureDetector::New(2);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
detector.Attach(actor);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 650 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 650));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 750 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 750));
application.SendNotification();
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 50.0f, 50.0f ), 950 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(50.0f, 50.0f), 950));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 50.0f, 50.0f ), 1000 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(50.0f, 50.0f), 1000));
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 50.0f, 50.0f ), 1050 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(50.0f, 50.0f), 1050));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 50.0f, 50.0f ), 1000 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(50.0f, 50.0f), 1000));
application.SendNotification();
END_TEST;
}
-
int UtcDaliTapGestureRecognizerMultipleDetectors(void)
{
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
Actor actor2 = Actor::New();
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor2.SetProperty( Actor::Property::POSITION_X, 100.0f);
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor2.SetProperty(Actor::Property::POSITION_X, 100.0f);
application.GetScene().Add(actor2);
// Render and notify
TapGestureDetector detector2 = TapGestureDetector::New(2);
detector2.Attach(actor2);
- SignalData data;
+ SignalData data;
GestureReceivedFunctor functor(data);
detector.DetectedSignal().Connect(&application, functor);
- SignalData data2;
+ SignalData data2;
GestureReceivedFunctor functor2(data2);
detector2.DetectedSignal().Connect(&application, functor2);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 20.0f, 20.0f ), 150 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(20.0f, 20.0f), 150));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 20.0f, 20.0f ), 200 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(20.0f, 20.0f), 200));
application.SendNotification();
data.Reset();
DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 120.0f, 20.0f ), 250 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(120.0f, 20.0f), 250));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 120.0f, 20.0f ), 300 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(120.0f, 20.0f), 300));
application.SendNotification();
DALI_TEST_EQUALS(false, data2.functorCalled, TEST_LOCATION);
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 120.0f, 20.0f ), 350 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(120.0f, 20.0f), 350));
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 120.0f, 20.0f ), 400 ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(120.0f, 20.0f), 400));
application.SendNotification();
*
*/
-#include <dali/public-api/dali-core.h>
-#include <dali/devel-api/images/pixel-data-devel.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/images/pixel-data-devel.h>
+#include <dali/devel-api/rendering/texture-devel.h>
+#include <dali/public-api/dali-core.h>
#include <test-native-image.h>
using namespace Dali;
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
- DALI_TEST_CHECK( texture );
+ DALI_TEST_CHECK(texture);
END_TEST;
}
int UtcDaliTextureNew02(void)
{
TestApplication application;
- Texture texture;
- DALI_TEST_CHECK( !texture );
+ Texture texture;
+ DALI_TEST_CHECK(!texture);
END_TEST;
}
TestApplication application;
// Create a native image source.
- TestNativeImagePointer testNativeImage = TestNativeImage::New( 64u, 64u );
+ TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
// Create a texture from the native image source.
- Texture nativeTexture = Texture::New( *testNativeImage );
+ Texture nativeTexture = Texture::New(*testNativeImage);
// Check the texture was created OK.
- DALI_TEST_CHECK( nativeTexture );
+ DALI_TEST_CHECK(nativeTexture);
END_TEST;
}
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
Texture textureCopy(texture);
- DALI_TEST_CHECK( textureCopy );
+ DALI_TEST_CHECK(textureCopy);
END_TEST;
}
int UtcDaliTextureAssignmentOperator(void)
{
TestApplication application;
- unsigned int width(64);
- unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ unsigned int width(64);
+ unsigned int height(64);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
Texture texture2;
- DALI_TEST_CHECK( !texture2 );
+ DALI_TEST_CHECK(!texture2);
texture2 = texture;
- DALI_TEST_CHECK( texture2 );
+ DALI_TEST_CHECK(texture2);
END_TEST;
}
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- DALI_TEST_CHECK( texture );
- DALI_TEST_EQUALS( 1, texture.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( texture.GetWidth(), width, TEST_LOCATION );
- DALI_TEST_EQUALS( texture.GetHeight(), height, TEST_LOCATION );
-
- Texture move = std::move( texture );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetWidth(), width, TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetHeight(), height, TEST_LOCATION );
- DALI_TEST_CHECK( !texture );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ DALI_TEST_CHECK(texture);
+ DALI_TEST_EQUALS(1, texture.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(texture.GetWidth(), width, TEST_LOCATION);
+ DALI_TEST_EQUALS(texture.GetHeight(), height, TEST_LOCATION);
+
+ Texture move = std::move(texture);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetWidth(), width, TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetHeight(), height, TEST_LOCATION);
+ DALI_TEST_CHECK(!texture);
END_TEST;
}
{
TestApplication application;
- uint32_t width = 64;
- uint32_t height = 64;
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- DALI_TEST_CHECK( texture );
- DALI_TEST_EQUALS( 1, texture.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( texture.GetWidth(), width, TEST_LOCATION );
- DALI_TEST_EQUALS( texture.GetHeight(), height, TEST_LOCATION );
+ uint32_t width = 64;
+ uint32_t height = 64;
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ DALI_TEST_CHECK(texture);
+ DALI_TEST_EQUALS(1, texture.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(texture.GetWidth(), width, TEST_LOCATION);
+ DALI_TEST_EQUALS(texture.GetHeight(), height, TEST_LOCATION);
Texture move;
- move = std::move( texture );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetWidth(), width, TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetHeight(), height, TEST_LOCATION );
- DALI_TEST_CHECK( !texture );
+ move = std::move(texture);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetWidth(), width, TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetHeight(), height, TEST_LOCATION);
+ DALI_TEST_CHECK(!texture);
END_TEST;
}
int UtcDaliTextureDownCast01(void)
{
TestApplication application;
- unsigned int width(64);
- unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ unsigned int width(64);
+ unsigned int height(64);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
BaseHandle handle(texture);
- Texture texture2 = Texture::DownCast(handle);
- DALI_TEST_CHECK( texture2 );
+ Texture texture2 = Texture::DownCast(handle);
+ DALI_TEST_CHECK(texture2);
END_TEST;
}
{
TestApplication application;
- Handle handle = Handle::New(); // Create a custom object
+ Handle handle = Handle::New(); // Create a custom object
Texture texture = Texture::DownCast(handle);
- DALI_TEST_CHECK( !texture );
+ DALI_TEST_CHECK(!texture);
END_TEST;
}
//Create the texture
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
//TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
//Upload data to the texture
callStack.Reset();
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelData );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelData);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
//Upload part of the texture
callStack.Reset();
- bufferSize = width * height * 2;
- buffer = reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelDataSubImage = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelDataSubImage, 0u, 0u, width/2, height/2, width/2, height/2 );
+ bufferSize = width * height * 2;
+ buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelDataSubImage = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelDataSubImage, 0u, 0u, width / 2, height / 2, width / 2, height / 2);
application.SendNotification();
application.Render();
//TexSubImage2D should be called to upload the data
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width/2 << ", " << height/2 << ", " << width/2 << ", " << height/2;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexSubImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width / 2 << ", " << height / 2 << ", " << width / 2 << ", " << height / 2;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexSubImage2D", out.str().c_str()));
}
-
END_TEST;
}
//Create the texture
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
//TexImage2D should be called six times with a null pointer to reserve storage for the six textures of the cube map
- for( unsigned int i(0); i<6; ++i )
+ for(unsigned int i(0); i < 6; ++i)
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_POSITIVE_X + i <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_POSITIVE_X + i << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
//Upload data to the POSITIVE_X face of the texture
{
callStack.Reset();
- texture.Upload( pixelData, CubeMapLayer::POSITIVE_X, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::POSITIVE_X, 0u, 0u, 0u, width, height);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to the POSITIVE_X face
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_POSITIVE_X <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_POSITIVE_X << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
{
callStack.Reset();
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to the NEGATIVE_X face
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
//Upload data to the POSITIVE_Y face of the texture
{
callStack.Reset();
- texture.Upload( pixelData, CubeMapLayer::POSITIVE_Y, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::POSITIVE_Y, 0u, 0u, 0u, width, height);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to the POSITIVE_Y face
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_POSITIVE_Y <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_POSITIVE_Y << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
//Upload data to the NEGATIVE_Y face of the texture
{
callStack.Reset();
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_Y, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_Y, 0u, 0u, 0u, width, height);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to the NEGATIVE_Y face
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_NEGATIVE_Y <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_NEGATIVE_Y << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
//Upload data to the POSITIVE_Z face of the texture
{
callStack.Reset();
- texture.Upload( pixelData, CubeMapLayer::POSITIVE_Z, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::POSITIVE_Z, 0u, 0u, 0u, width, height);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to the POSITIVE_Z face
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_POSITIVE_Z <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_POSITIVE_Z << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
//Upload data to the NEGATIVE_Z face of the texture
{
callStack.Reset();
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_Z, 0u, 0u, 0u, width, height );
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_Z, 0u, 0u, 0u, width, height);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to the NEGATIVE_Z face
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_NEGATIVE_Z <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_NEGATIVE_Z << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
unsigned int widthMipmap1(32);
unsigned int heightMipmap1(32);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
//TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
//Upload data to the texture mipmap 0 and mipmap 1
callStack.Reset();
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelData, 0u, 0u, 0u, 0u, width, height );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelData, 0u, 0u, 0u, 0u, width, height);
- bufferSize = widthMipmap1 * heightMipmap1 * 4;
- buffer = reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelDataMipmap1 = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelDataMipmap1, 0u, 1u, 0u, 0u, widthMipmap1, heightMipmap1 );
+ bufferSize = widthMipmap1 * heightMipmap1 * 4;
+ buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelDataMipmap1 = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelDataMipmap1, 0u, 1u, 0u, 0u, widthMipmap1, heightMipmap1);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to mipmaps 0 and 1
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 1u << ", " << widthMipmap1 <<", "<< heightMipmap1;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 1u << ", " << widthMipmap1 << ", " << heightMipmap1;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
END_TEST;
unsigned int widthMipmap1(32);
unsigned int heightMipmap1(32);
- Texture texture = Texture::New( TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
//Upload data to the NEGATIVE_X face mipmap 0 and mipmap 1
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height );
-
- bufferSize = widthMipmap1 * heightMipmap1 * 4;
- buffer = reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelDataMipmap1 = PixelData::New( buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelDataMipmap1, CubeMapLayer::NEGATIVE_X, 1u, 0u, 0u, widthMipmap1, heightMipmap1 );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelData, CubeMapLayer::NEGATIVE_X, 0u, 0u, 0u, width, height);
+
+ bufferSize = widthMipmap1 * heightMipmap1 * 4;
+ buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelDataMipmap1 = PixelData::New(buffer, bufferSize, width, height, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelDataMipmap1, CubeMapLayer::NEGATIVE_X, 1u, 0u, 0u, widthMipmap1, heightMipmap1);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data to mipmaps 0 and 1
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
{
std::stringstream out;
- out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X <<", "<< 1u << ", " << widthMipmap1 <<", "<< heightMipmap1;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_CUBE_MAP_NEGATIVE_X << ", " << 1u << ", " << widthMipmap1 << ", " << heightMipmap1;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
END_TEST;
int UtcDaliTextureUpload05(void)
{
Pixel::Format COMPRESSED_PIXEL_FORMATS[] =
- {
- Pixel::COMPRESSED_R11_EAC,
- Pixel::COMPRESSED_SIGNED_R11_EAC,
- Pixel::COMPRESSED_RG11_EAC,
- Pixel::COMPRESSED_SIGNED_RG11_EAC,
- Pixel::COMPRESSED_RGB8_ETC2,
- Pixel::COMPRESSED_SRGB8_ETC2,
- Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
- Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
- Pixel::COMPRESSED_RGBA8_ETC2_EAC,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
- Pixel::COMPRESSED_RGB8_ETC1,
- Pixel::COMPRESSED_RGB_PVRTC_4BPPV1,
- Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR,
- Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
- Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
- };
- const unsigned int NUMBER_OF_COMPRESSED_PIXEL_FORMATS = sizeof( COMPRESSED_PIXEL_FORMATS ) / sizeof( Pixel::Format );
-
- for( unsigned int index = 0; index < NUMBER_OF_COMPRESSED_PIXEL_FORMATS; ++index )
+ {
+ Pixel::COMPRESSED_R11_EAC,
+ Pixel::COMPRESSED_SIGNED_R11_EAC,
+ Pixel::COMPRESSED_RG11_EAC,
+ Pixel::COMPRESSED_SIGNED_RG11_EAC,
+ Pixel::COMPRESSED_RGB8_ETC2,
+ Pixel::COMPRESSED_SRGB8_ETC2,
+ Pixel::COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+ Pixel::COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,
+ Pixel::COMPRESSED_RGBA8_ETC2_EAC,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ETC2_EAC,
+ Pixel::COMPRESSED_RGB8_ETC1,
+ Pixel::COMPRESSED_RGB_PVRTC_4BPPV1,
+ Pixel::COMPRESSED_RGBA_ASTC_4x4_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_5x4_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_5x5_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_6x5_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_6x6_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_8x5_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_8x6_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_8x8_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_10x5_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_10x6_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_10x8_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_10x10_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_12x10_KHR,
+ Pixel::COMPRESSED_RGBA_ASTC_12x12_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR,
+ Pixel::COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR,
+ };
+ const unsigned int NUMBER_OF_COMPRESSED_PIXEL_FORMATS = sizeof(COMPRESSED_PIXEL_FORMATS) / sizeof(Pixel::Format);
+
+ for(unsigned int index = 0; index < NUMBER_OF_COMPRESSED_PIXEL_FORMATS; ++index)
{
TestApplication application;
//Create a texture with a compressed format
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, COMPRESSED_PIXEL_FORMATS[index], width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, COMPRESSED_PIXEL_FORMATS[index], width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
//CompressedTexImage2D should be called with a null pointer to reserve storage for the texture in the gpu
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("CompressedTexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("CompressedTexImage2D", out.str().c_str()));
}
//Upload data to the texture
callStack.Reset();
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, COMPRESSED_PIXEL_FORMATS[index], PixelData::FREE );
- texture.Upload( pixelData );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, COMPRESSED_PIXEL_FORMATS[index], PixelData::FREE);
+ texture.Upload(pixelData);
application.SendNotification();
application.Render();
//CompressedTexImage2D should be called to upload the data
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("CompressedTexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("CompressedTexImage2D", out.str().c_str()));
}
//Upload part of the texture
callStack.Reset();
- bufferSize = width * height * 2;
- buffer = reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelDataSubImage = PixelData::New( buffer, bufferSize, width, height, COMPRESSED_PIXEL_FORMATS[index], PixelData::FREE );
- texture.Upload( pixelDataSubImage, 0u, 0u, width/2, height/2, width/2, height/2 );
+ bufferSize = width * height * 2;
+ buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelDataSubImage = PixelData::New(buffer, bufferSize, width, height, COMPRESSED_PIXEL_FORMATS[index], PixelData::FREE);
+ texture.Upload(pixelDataSubImage, 0u, 0u, width / 2, height / 2, width / 2, height / 2);
application.SendNotification();
application.Render();
//CompressedTexSubImage2D should be called to upload the data
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width/2 << ", " << height/2 << ", " << width/2 << ", " << height/2;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("CompressedTexSubImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width / 2 << ", " << height / 2 << ", " << width / 2 << ", " << height / 2;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("CompressedTexSubImage2D", out.str().c_str()));
}
application.GetGlAbstraction().ResetTextureCallStack();
//Create the texture
unsigned int width(64);
unsigned int height(64);
- tet_infoline( "Creating a Texure with an alpha channel" );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ tet_infoline("Creating a Texure with an alpha channel");
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
- tet_infoline( "TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu" );
+ tet_infoline("TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
- tet_infoline( "Upload data to the texture" );
+ tet_infoline("Upload data to the texture");
callStack.Reset();
- tet_infoline( "Creating a RGB pixel buffer and adding that to the texture to ensure it is handled correctly" );
- unsigned int bufferSize( width * height * 3 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, Pixel::RGB888, PixelData::FREE );
- texture.Upload( pixelData );
+ tet_infoline("Creating a RGB pixel buffer and adding that to the texture to ensure it is handled correctly");
+ unsigned int bufferSize(width * height * 3);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, Pixel::RGB888, PixelData::FREE);
+ texture.Upload(pixelData);
application.SendNotification();
application.Render();
- tet_infoline( "TexImage2D should be called to upload the data" );
+ tet_infoline("TexImage2D should be called to upload the data");
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
END_TEST;
int UtcDaliTextureUpload07(void)
{
Pixel::Format FLOATING_POINT_PIXEL_FORMATS[] =
- {
- Pixel::RGB16F,
- Pixel::RGB32F,
- };
- const unsigned int NUMBER_OF_FLOATING_POINT_PIXEL_FORMATS = sizeof( FLOATING_POINT_PIXEL_FORMATS ) / sizeof( Pixel::Format );
+ {
+ Pixel::RGB16F,
+ Pixel::RGB32F,
+ };
+ const unsigned int NUMBER_OF_FLOATING_POINT_PIXEL_FORMATS = sizeof(FLOATING_POINT_PIXEL_FORMATS) / sizeof(Pixel::Format);
- for( unsigned int index = 0; index < NUMBER_OF_FLOATING_POINT_PIXEL_FORMATS; ++index )
+ for(unsigned int index = 0; index < NUMBER_OF_FLOATING_POINT_PIXEL_FORMATS; ++index)
{
TestApplication application;
//Create the texture
unsigned int width(64);
unsigned int height(64);
- tet_infoline( "Creating a floating point texture" );
- Texture texture = Texture::New( TextureType::TEXTURE_2D, FLOATING_POINT_PIXEL_FORMATS[index], width, height );
+ tet_infoline("Creating a floating point texture");
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, FLOATING_POINT_PIXEL_FORMATS[index], width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
TraceCallStack& callStack = application.GetGlAbstraction().GetTextureTrace();
- tet_infoline( "TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu" );
+ tet_infoline("TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu");
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
- tet_infoline( "Upload data to the texture" );
+ tet_infoline("Upload data to the texture");
callStack.Reset();
- tet_infoline( "Creating a RGB pixel buffer and adding that to the texture to ensure it is handled correctly" );
- unsigned int bufferSize( width * height * 3 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width, height, FLOATING_POINT_PIXEL_FORMATS[index], PixelData::FREE );
- texture.Upload( pixelData );
+ tet_infoline("Creating a RGB pixel buffer and adding that to the texture to ensure it is handled correctly");
+ unsigned int bufferSize(width * height * 3);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width, height, FLOATING_POINT_PIXEL_FORMATS[index], PixelData::FREE);
+ texture.Upload(pixelData);
application.SendNotification();
application.Render();
- tet_infoline( "TexImage2D should be called to upload the data" );
+ tet_infoline("TexImage2D should be called to upload the data");
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("TexImage2D", out.str().c_str() ) );
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("TexImage2D", out.str().c_str()));
}
}
//Create the texture
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
application.GetGlAbstraction().EnableTextureCallTrace(true);
//TexImage2D should be called with a null pointer to reserve storage for the texture in the gpu
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << width <<", "<< height;
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << width << ", " << height;
std::string params;
- DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("TexImage2D", params ) );
- DALI_TEST_EQUALS( out.str(), params, TEST_LOCATION );
+ DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("TexImage2D", params));
+ DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
}
//Upload data to the texture
callStack.Reset();
- unsigned int bufferSize( width * height * 4 );
- unsigned char* buffer= reinterpret_cast<unsigned char*>( malloc( bufferSize ) );
- PixelData pixelData = PixelData::New( buffer, bufferSize, width/2, height/2, Pixel::RGBA8888, PixelData::FREE );
- texture.Upload( pixelData );
+ unsigned int bufferSize(width * height * 4);
+ unsigned char* buffer = reinterpret_cast<unsigned char*>(malloc(bufferSize));
+ PixelData pixelData = PixelData::New(buffer, bufferSize, width / 2, height / 2, Pixel::RGBA8888, PixelData::FREE);
+ texture.Upload(pixelData);
application.SendNotification();
application.Render();
//TexImage2D should be called to upload the data
{
std::stringstream out;
- out << GL_TEXTURE_2D <<", "<< 0u << ", " << 0u << ", " << 0u << ", " << width/2 << ", " << height/2;
+ out << GL_TEXTURE_2D << ", " << 0u << ", " << 0u << ", " << 0u << ", " << width / 2 << ", " << height / 2;
std::string params;
- DALI_TEST_CHECK( callStack.FindMethodAndGetParameters("TexSubImage2D", params ) );
- DALI_TEST_EQUALS( out.str(), params, TEST_LOCATION );
+ DALI_TEST_CHECK(callStack.FindMethodAndGetParameters("TexSubImage2D", params));
+ DALI_TEST_EQUALS(out.str(), params, TEST_LOCATION);
}
END_TEST;
int UtcDaliTextureGenerateMipmaps(void)
{
TestApplication application;
- unsigned int width(64);
- unsigned int height(64);
+ unsigned int width(64);
+ unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
texture.GenerateMipmaps();
- Texture textureCubemap = Texture::New( TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height );
+ Texture textureCubemap = Texture::New(TextureType::TEXTURE_CUBE, Pixel::RGBA8888, width, height);
textureCubemap.GenerateMipmaps();
application.GetGlAbstraction().EnableTextureCallTrace(true);
{
std::stringstream out;
out << GL_TEXTURE_2D;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("GenerateMipmap", out.str().c_str() ) );
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("GenerateMipmap", out.str().c_str()));
}
{
std::stringstream out;
out << GL_TEXTURE_CUBE_MAP;
- DALI_TEST_CHECK( callStack.FindMethodAndParams("GenerateMipmap", out.str().c_str() ) );
+ DALI_TEST_CHECK(callStack.FindMethodAndParams("GenerateMipmap", out.str().c_str()));
}
END_TEST;
int UtcDaliTextureGetWidth(void)
{
TestApplication application;
- unsigned int width(64);
- unsigned int height(64);
+ unsigned int width(64);
+ unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- DALI_TEST_EQUALS( texture.GetWidth(), width, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ DALI_TEST_EQUALS(texture.GetWidth(), width, TEST_LOCATION);
END_TEST;
}
int UtcDaliTextureGetHeight(void)
{
TestApplication application;
- unsigned int width(64);
- unsigned int height(64);
+ unsigned int width(64);
+ unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- DALI_TEST_EQUALS( texture.GetHeight(), height, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ DALI_TEST_EQUALS(texture.GetHeight(), height, TEST_LOCATION);
END_TEST;
}
//Create the texture
unsigned int width(64);
unsigned int height(64);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height );
- DALI_TEST_CHECK( texture );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+ DALI_TEST_CHECK(texture);
application.SendNotification();
application.Render(16);
// Lose & regain context (in render 'thread')
application.ResetContext();
- DALI_TEST_CHECK( texture );
+ DALI_TEST_CHECK(texture);
END_TEST;
}
int UtcDaliNativeImageTexture01(void)
{
TestApplication application;
- tet_infoline( "UtcDaliNativeImageTexture01" );
+ tet_infoline("UtcDaliNativeImageTexture01");
- TestNativeImagePointer imageInterface = TestNativeImage::New( 16, 16 );
+ TestNativeImagePointer imageInterface = TestNativeImage::New(16, 16);
{
- Texture texture = Texture::New( *(imageInterface.Get()) );
- Actor actor = CreateRenderableActor(texture, "", "");
+ Texture texture = Texture::New(*(imageInterface.Get()));
+ Actor actor = CreateRenderableActor(texture, "", "");
application.GetScene().Add(actor);
- DALI_TEST_CHECK( texture );
+ DALI_TEST_CHECK(texture);
application.SendNotification();
application.Render(16);
- DALI_TEST_EQUALS( imageInterface->mExtensionCreateCalls, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( imageInterface->mExtensionDestroyCalls, 0, TEST_LOCATION );
- DALI_TEST_EQUALS( actor.GetProperty(Actor::Property::SIZE), Property::Value(Vector3(16,16,0)), TEST_LOCATION);
+ DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 0, TEST_LOCATION);
+ DALI_TEST_EQUALS(actor.GetProperty(Actor::Property::SIZE), Property::Value(Vector3(16, 16, 0)), TEST_LOCATION);
UnparentAndReset(actor);
application.SendNotification();
application.Render(16);
- DALI_TEST_EQUALS( imageInterface->mExtensionCreateCalls, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( imageInterface->mExtensionDestroyCalls, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 1, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliNativeImageTexture02(void)
{
TestApplication application;
- tet_infoline( "UtcDaliNativeImageTexture02 - test error on TargetTexture" );
+ tet_infoline("UtcDaliNativeImageTexture02 - test error on TargetTexture");
- TestNativeImagePointer imageInterface = TestNativeImage::New( 16, 16 );
- imageInterface->mTargetTextureError = 1u;
+ TestNativeImagePointer imageInterface = TestNativeImage::New(16, 16);
+ imageInterface->mTargetTextureError = 1u;
{
- Texture texture = Texture::New( *(imageInterface.Get()) );
- Actor actor = CreateRenderableActor(texture, "", "");
+ Texture texture = Texture::New(*(imageInterface.Get()));
+ Actor actor = CreateRenderableActor(texture, "", "");
application.GetScene().Add(actor);
- DALI_TEST_CHECK( texture );
+ DALI_TEST_CHECK(texture);
application.SendNotification();
application.Render(16);
// Expect 2 attempts to create the texture - once when adding the texture
// to the scene-graph, and again since that failed, during the Bind.
- DALI_TEST_EQUALS( imageInterface->mExtensionCreateCalls, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( imageInterface->mExtensionDestroyCalls, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 2, TEST_LOCATION);
UnparentAndReset(actor);
application.Render(16);
// Expect that there are no further calls to create/destroy resource
- DALI_TEST_EQUALS( imageInterface->mExtensionCreateCalls, 2, TEST_LOCATION );
- DALI_TEST_EQUALS( imageInterface->mExtensionDestroyCalls, 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(imageInterface->mExtensionCreateCalls, 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(imageInterface->mExtensionDestroyCalls, 2, TEST_LOCATION);
END_TEST;
}
int UtcDaliTextureGenerateMipmapsNegative(void)
{
TestApplication application;
- Dali::Texture instance;
+ Dali::Texture instance;
try
{
instance.GenerateMipmaps();
int UtcDaliTextureUploadNegative01(void)
{
TestApplication application;
- Dali::Texture instance;
+ Dali::Texture instance;
try
{
Dali::PixelData arg1;
int UtcDaliTextureUploadNegative02(void)
{
TestApplication application;
- Dali::Texture instance;
+ Dali::Texture instance;
try
{
Dali::PixelData arg1;
- unsigned int arg2(0u);
- unsigned int arg3(0u);
- unsigned int arg4(0u);
- unsigned int arg5(0u);
- unsigned int arg6(0u);
- unsigned int arg7(0u);
- instance.Upload(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
+ unsigned int arg2(0u);
+ unsigned int arg3(0u);
+ unsigned int arg4(0u);
+ unsigned int arg5(0u);
+ unsigned int arg6(0u);
+ unsigned int arg7(0u);
+ instance.Upload(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliTextureGetWidthNegative(void)
{
TestApplication application;
- Dali::Texture instance;
+ Dali::Texture instance;
try
{
instance.GetWidth();
int UtcDaliTextureGetHeightNegative(void)
{
TestApplication application;
- Dali::Texture instance;
+ Dali::Texture instance;
try
{
instance.GetHeight();
}
END_TEST;
}
+
+int UtcDaliTextureCheckNativeP(void)
+{
+ TestApplication application;
+ TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
+ Texture nativeTexture = Texture::New(*testNativeImage);
+
+ DALI_TEST_CHECK(nativeTexture);
+ DALI_TEST_CHECK(DevelTexture::IsNative(nativeTexture));
+ END_TEST;
+}
+
+int UtcDaliTextureCheckNativeN1(void)
+{
+ TestApplication application;
+ unsigned int width(64);
+ unsigned int height(64);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+
+ DALI_TEST_CHECK(texture);
+ DALI_TEST_CHECK(!DevelTexture::IsNative(texture));
+ END_TEST;
+}
+
+int UtcDaliTextureCheckNativeN2(void)
+{
+ TestApplication application;
+ Texture texture;
+ try
+ {
+ bool native = DevelTexture::IsNative(texture);
+ DALI_TEST_CHECK(native != native);
+ }
+ catch(...)
+ {
+ DALI_TEST_CHECK(true);
+ }
+ END_TEST;
+}
+
+int UtcDaliTextureApplyFragShaderP1(void)
+{
+ TestApplication application;
+ TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
+ Texture nativeTexture = Texture::New(*testNativeImage);
+ DALI_TEST_CHECK(nativeTexture);
+
+ const std::string baseFragShader =
+ "varying mediump vec4 uColor;\n"
+ "void main(){\n"
+ " gl_FragColor=uColor;\n"
+ "}\n";
+ std::string fragShader = baseFragShader;
+ bool applied = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragShader);
+
+ DALI_TEST_CHECK(applied);
+ DALI_TEST_CHECK(baseFragShader.compare(fragShader));
+ DALI_TEST_CHECK(!fragShader.empty());
+ END_TEST;
+}
+
+int UtcDaliTextureApplyFragShaderP2(void)
+{
+ TestApplication application;
+ TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
+ Texture nativeTexture = Texture::New(*testNativeImage);
+ DALI_TEST_CHECK(nativeTexture);
+
+ const std::string baseFragShader =
+ "varying mediump vec4 uColor;\n"
+ "varying vec2 vTexCoord;\n"
+ "uniform sampler2D uNative;\n"
+ "void main(){\n"
+ " gl_FragColor=uColor*texture2D(uNative, vTexCoord);\n"
+ "}\n";
+ std::string fragShader = baseFragShader;
+ bool applied = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragShader);
+
+ DALI_TEST_CHECK(applied);
+ DALI_TEST_CHECK(baseFragShader.compare(fragShader));
+ DALI_TEST_CHECK(!fragShader.empty());
+ DALI_TEST_CHECK(fragShader.find("samplerExternalOES") < fragShader.length());
+ END_TEST;
+}
+
+int UtcDaliTextureApplyFragShaderN1(void)
+{
+ TestApplication application;
+ TestNativeImagePointer testNativeImage = TestNativeImage::New(64u, 64u);
+ Texture nativeTexture = Texture::New(*testNativeImage);
+ DALI_TEST_CHECK(nativeTexture);
+
+ std::string fragShader;
+ bool applied = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragShader);
+
+ DALI_TEST_CHECK(!applied);
+ DALI_TEST_CHECK(fragShader.empty());
+ END_TEST;
+}
+
+int UtcDaliTextureApplyFragShaderN2(void)
+{
+ TestApplication application;
+ unsigned int width(64);
+ unsigned int height(64);
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, width, height);
+
+ const std::string baseFragShader =
+ "varying mediump vec4 uColor;\n"
+ "void main(){\n"
+ " gl_FragColor=uColor;\n"
+ "}\n";
+ std::string fragShader = baseFragShader;
+ bool applied = DevelTexture::ApplyNativeFragmentShader(texture, fragShader);
+
+ DALI_TEST_CHECK(!applied);
+ DALI_TEST_CHECK(!baseFragShader.compare(fragShader));
+ END_TEST;
+}
namespace
{
-
enum SetSampler
{
SET_SAMPLER,
DONT_SET_SAMPLER
};
-Actor CreateActor( SetSampler setSamplerOption )
+Actor CreateActor(SetSampler setSamplerOption)
{
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64 );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
TextureSet textureSet = CreateTextureSet();
Sampler sampler = Sampler::New();
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
- textureSet.SetTexture( 0u, texture );
- if( setSamplerOption == SET_SAMPLER )
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
+ textureSet.SetTexture(0u, texture);
+ if(setSamplerOption == SET_SAMPLER)
{
- textureSet.SetSampler( 0u, sampler );
+ textureSet.SetSampler(0u, sampler);
}
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
return actor;
}
} // namespace
-
void texture_set_test_startup(void)
{
test_return_value = TET_UNDEF;
TextureSet textureSet = TextureSet::New();
- DALI_TEST_CHECK( textureSet );
+ DALI_TEST_CHECK(textureSet);
END_TEST;
}
int UtcDaliTextureSetNew02(void)
{
TestApplication application;
- TextureSet textureSet;
- DALI_TEST_CHECK( !textureSet );
+ TextureSet textureSet;
+ DALI_TEST_CHECK(!textureSet);
END_TEST;
}
{
TestApplication application;
- Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 32, 32);
+ Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 32, 32);
TextureSet textureSet = TextureSet::New();
- textureSet.SetTexture( 0u, image );
+ textureSet.SetTexture(0u, image);
TextureSet textureSetCopy(textureSet);
- DALI_TEST_CHECK( textureSetCopy );
+ DALI_TEST_CHECK(textureSetCopy);
END_TEST;
}
int UtcDaliTextureSetAssignmentOperator(void)
{
TestApplication application;
- TextureSet textureSet = TextureSet::New();
+ TextureSet textureSet = TextureSet::New();
TextureSet textureSet2;
- DALI_TEST_CHECK( !textureSet2 );
+ DALI_TEST_CHECK(!textureSet2);
textureSet2 = textureSet;
- DALI_TEST_CHECK( textureSet2 );
+ DALI_TEST_CHECK(textureSet2);
END_TEST;
}
TestApplication application;
TextureSet textureSet = TextureSet::New();
- DALI_TEST_CHECK( textureSet );
- DALI_TEST_EQUALS( 1, textureSet.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(textureSet);
+ DALI_TEST_EQUALS(1, textureSet.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 32, 32 );
- textureSet.SetTexture( 0u, texture );
- DALI_TEST_EQUALS( textureSet.GetTexture( 0u ), texture, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 32, 32);
+ textureSet.SetTexture(0u, texture);
+ DALI_TEST_EQUALS(textureSet.GetTexture(0u), texture, TEST_LOCATION);
- TextureSet move = std::move( textureSet );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetTexture( 0u ), texture, TEST_LOCATION );
- DALI_TEST_CHECK( !textureSet );
+ TextureSet move = std::move(textureSet);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetTexture(0u), texture, TEST_LOCATION);
+ DALI_TEST_CHECK(!textureSet);
END_TEST;
}
TestApplication application;
TextureSet textureSet = TextureSet::New();
- DALI_TEST_CHECK( textureSet );
- DALI_TEST_EQUALS( 1, textureSet.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(textureSet);
+ DALI_TEST_EQUALS(1, textureSet.GetBaseObject().ReferenceCount(), TEST_LOCATION);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 32, 32 );
- textureSet.SetTexture( 0u, texture );
- DALI_TEST_EQUALS( textureSet.GetTexture( 0u ), texture, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 32, 32);
+ textureSet.SetTexture(0u, texture);
+ DALI_TEST_EQUALS(textureSet.GetTexture(0u), texture, TEST_LOCATION);
TextureSet move;
- move = std::move( textureSet );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( move.GetTexture( 0u ), texture, TEST_LOCATION );
- DALI_TEST_CHECK( !textureSet );
+ move = std::move(textureSet);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(move.GetTexture(0u), texture, TEST_LOCATION);
+ DALI_TEST_CHECK(!textureSet);
END_TEST;
}
int UtcDaliTextureSetDownCast01(void)
{
TestApplication application;
- TextureSet textureSet = TextureSet::New();
+ TextureSet textureSet = TextureSet::New();
BaseHandle handle(textureSet);
TextureSet textureSet2 = TextureSet::DownCast(handle);
- DALI_TEST_CHECK( textureSet2 );
+ DALI_TEST_CHECK(textureSet2);
END_TEST;
}
{
TestApplication application;
- Handle handle = Handle::New(); // Create a custom object
+ Handle handle = Handle::New(); // Create a custom object
TextureSet textureSet = TextureSet::DownCast(handle);
- DALI_TEST_CHECK( !textureSet );
+ DALI_TEST_CHECK(!textureSet);
END_TEST;
}
-
int UtcDaliTextureSetTexture01(void)
{
TestApplication application;
- Actor actor = CreateActor( DONT_SET_SAMPLER );
+ Actor actor = CreateActor(DONT_SET_SAMPLER);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
application.SendNotification();
application.Render();
- int textureUnit=-1;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+ int textureUnit = -1;
+ DALI_TEST_CHECK(gl.GetUniformValue<int>("sTexture", textureUnit));
+ DALI_TEST_EQUALS(textureUnit, 0, TEST_LOCATION);
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// There are four calls to TexParameteri when the texture is first created
// as the texture is using default sampling parametrers there shouldn't be any more calls to TexParameteri
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 4, TEST_LOCATION);
END_TEST;
}
Actor actor = CreateActor(SET_SAMPLER);
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
application.SendNotification();
application.Render();
- int textureUnit=-1;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+ int textureUnit = -1;
+ DALI_TEST_CHECK(gl.GetUniformValue<int>("sTexture", textureUnit));
+ DALI_TEST_EQUALS(textureUnit, 0, TEST_LOCATION);
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// There are four calls to TexParameteri when the texture is first created
// Texture minification and magnification filters are now different than default so
//there should have been two extra TexParameteri calls to set the new filter mode
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 6, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 6, TEST_LOCATION);
END_TEST;
}
Actor actor1 = CreateActor(SET_SAMPLER);
Actor actor2 = CreateActor(SET_SAMPLER);
- application.GetScene().Add( actor1 );
- application.GetScene().Add( actor2 );
+ application.GetScene().Add(actor1);
+ application.GetScene().Add(actor2);
TestGlAbstraction& gl = application.GetGlAbstraction();
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
application.SendNotification();
application.Render();
- int textureUnit=-1;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+ int textureUnit = -1;
+ DALI_TEST_CHECK(gl.GetUniformValue<int>("sTexture", textureUnit));
+ DALI_TEST_EQUALS(textureUnit, 0, TEST_LOCATION);
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// For each actor there are four calls to TexParameteri when the texture is first created
// Texture minification and magnification filters are now different than default so
//there should have been two extra TexParameteri calls to set the new filter mode
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2 * 6, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 2 * 6, TEST_LOCATION);
END_TEST;
}
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- Shader shader = CreateShader();
- TextureSet textureSet = CreateTextureSet( image );
+ Shader shader = CreateShader();
+ TextureSet textureSet = CreateTextureSet(image);
Geometry geometry = CreateQuadGeometry();
- Renderer renderer = Renderer::New( geometry, shader );
- renderer.SetTextures( textureSet );
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
Actor actor = Actor::New();
actor.AddRenderer(renderer);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
- actor.SetProperty( Actor::Property::SIZE, Vector2( 400.0f, 400.0f ) );
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
- application.GetScene().Add( actor );
+ application.GetScene().Add(actor);
TestGlAbstraction& gl = application.GetGlAbstraction();
TraceCallStack& texParameterTrace = gl.GetTexParameterTrace();
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
application.SendNotification();
application.Render();
- int textureUnit=-1;
- DALI_TEST_CHECK( gl.GetUniformValue<int>( "sTexture", textureUnit ) );
- DALI_TEST_EQUALS( textureUnit, 0, TEST_LOCATION );
+ int textureUnit = -1;
+ DALI_TEST_CHECK(gl.GetUniformValue<int>("sTexture", textureUnit));
+ DALI_TEST_EQUALS(textureUnit, 0, TEST_LOCATION);
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
// There are 4 calls to TexParameteri when the texture is first created
// as the texture is using default sampling parametrers there shouldn't be any more calls to TexParameteri
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 4, TEST_LOCATION);
texParameterTrace.Reset();
- texParameterTrace.Enable( true );
+ texParameterTrace.Enable(true);
Sampler sampler = Sampler::New();
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
- textureSet.SetSampler( 0u, sampler );
-
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
+ textureSet.SetSampler(0u, sampler);
application.SendNotification();
application.Render();
- texParameterTrace.Enable( false );
+ texParameterTrace.Enable(false);
// Verify gl state
//There should have been two calls to TexParameteri to set the new filtering mode
- DALI_TEST_EQUALS( texParameterTrace.CountMethod( "TexParameteri" ), 2, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(texParameterTrace.CountMethod("TexParameteri"), 2, TEST_LOCATION);
END_TEST;
}
TestApplication application;
TextureSet textureSet = CreateTextureSet();
- DALI_TEST_EQUALS( textureSet.GetTexture(0), Texture(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(1), Texture(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(2), Texture(), TEST_LOCATION );
+ DALI_TEST_EQUALS(textureSet.GetTexture(0), Texture(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(1), Texture(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(2), Texture(), TEST_LOCATION);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64 );
- textureSet.SetTexture( 0u, texture );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
+ textureSet.SetTexture(0u, texture);
- DALI_TEST_EQUALS( textureSet.GetTexture(0), texture, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(1), Texture(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(2), Texture(), TEST_LOCATION );
+ DALI_TEST_EQUALS(textureSet.GetTexture(0), texture, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(1), Texture(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(2), Texture(), TEST_LOCATION);
- textureSet.SetTexture( 2u, texture );
- DALI_TEST_EQUALS( textureSet.GetTexture(0), texture, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(1), Texture(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(2), texture, TEST_LOCATION );
+ textureSet.SetTexture(2u, texture);
+ DALI_TEST_EQUALS(textureSet.GetTexture(0), texture, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(1), Texture(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(2), texture, TEST_LOCATION);
- textureSet.SetTexture( 2u, Texture() );
- DALI_TEST_EQUALS( textureSet.GetTexture(0), texture, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(1), Texture(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetTexture(2), Texture(), TEST_LOCATION );
+ textureSet.SetTexture(2u, Texture());
+ DALI_TEST_EQUALS(textureSet.GetTexture(0), texture, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(1), Texture(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetTexture(2), Texture(), TEST_LOCATION);
END_TEST;
}
TestApplication application;
TextureSet textureSet = CreateTextureSet();
- DALI_TEST_EQUALS( textureSet.GetSampler(0), Sampler(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(1), Sampler(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(2), Sampler(), TEST_LOCATION );
+ DALI_TEST_EQUALS(textureSet.GetSampler(0), Sampler(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(1), Sampler(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(2), Sampler(), TEST_LOCATION);
Sampler sampler = Sampler::New();
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
- textureSet.SetSampler( 0u, sampler );
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
+ textureSet.SetSampler(0u, sampler);
- DALI_TEST_EQUALS( textureSet.GetSampler(0), sampler, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(1), Sampler(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(2), Sampler(), TEST_LOCATION );
+ DALI_TEST_EQUALS(textureSet.GetSampler(0), sampler, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(1), Sampler(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(2), Sampler(), TEST_LOCATION);
- textureSet.SetSampler( 2u, sampler );
- DALI_TEST_EQUALS( textureSet.GetSampler(0), sampler, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(1), Sampler(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(2), sampler, TEST_LOCATION );
+ textureSet.SetSampler(2u, sampler);
+ DALI_TEST_EQUALS(textureSet.GetSampler(0), sampler, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(1), Sampler(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(2), sampler, TEST_LOCATION);
- textureSet.SetSampler( 2u, Sampler() );
- DALI_TEST_EQUALS( textureSet.GetSampler(0), sampler, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(1), Sampler(), TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(2), Sampler(), TEST_LOCATION );
+ textureSet.SetSampler(2u, Sampler());
+ DALI_TEST_EQUALS(textureSet.GetSampler(0), sampler, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(1), Sampler(), TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(2), Sampler(), TEST_LOCATION);
END_TEST;
}
TestApplication application;
TextureSet textureSet = CreateTextureSet();
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 0u, TEST_LOCATION);
Texture image = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
- textureSet.SetTexture( 0u, image );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 1u, TEST_LOCATION );
+ textureSet.SetTexture(0u, image);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 1u, TEST_LOCATION);
- textureSet.SetTexture( 1u, image );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 2u, TEST_LOCATION );
+ textureSet.SetTexture(1u, image);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 2u, TEST_LOCATION);
Sampler sampler = Sampler::New();
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
- textureSet.SetSampler( 2u, sampler );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 2u, TEST_LOCATION );
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
+ textureSet.SetSampler(2u, sampler);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 2u, TEST_LOCATION);
- textureSet.SetTexture( 2u, image );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 3u, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(2u), sampler, TEST_LOCATION );
+ textureSet.SetTexture(2u, image);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(2u), sampler, TEST_LOCATION);
END_TEST;
}
TestApplication application;
TextureSet textureSet = CreateTextureSet();
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 0u, TEST_LOCATION);
- Texture texture = Texture::New( TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64 );
- textureSet.SetTexture( 0u, texture );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 1u, TEST_LOCATION );
+ Texture texture = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
+ textureSet.SetTexture(0u, texture);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 1u, TEST_LOCATION);
- textureSet.SetTexture( 1u, texture );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 2u, TEST_LOCATION );
+ textureSet.SetTexture(1u, texture);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 2u, TEST_LOCATION);
Sampler sampler = Sampler::New();
- sampler.SetFilterMode( FilterMode::NEAREST, FilterMode::NEAREST );
- textureSet.SetSampler( 2u, sampler );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 2u, TEST_LOCATION );
-
- textureSet.SetTexture( 2u, texture );
- DALI_TEST_EQUALS( textureSet.GetTextureCount(), 3u, TEST_LOCATION );
- DALI_TEST_EQUALS( textureSet.GetSampler(2u), sampler, TEST_LOCATION );
+ sampler.SetFilterMode(FilterMode::NEAREST, FilterMode::NEAREST);
+ textureSet.SetSampler(2u, sampler);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 2u, TEST_LOCATION);
+ textureSet.SetTexture(2u, texture);
+ DALI_TEST_EQUALS(textureSet.GetTextureCount(), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(textureSet.GetSampler(2u), sampler, TEST_LOCATION);
END_TEST;
}
int UtcDaliTextureSetSetSamplerNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TextureSet instance;
try
{
unsigned long arg1(0u);
Dali::Sampler arg2;
- instance.SetSampler(arg1,arg2);
+ instance.SetSampler(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliTextureSetSetTextureNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TextureSet instance;
try
{
unsigned long arg1(0u);
Dali::Texture arg2;
- instance.SetTexture(arg1,arg2);
+ instance.SetTexture(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliTextureSetGetSamplerNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TextureSet instance;
try
{
int UtcDaliTextureSetGetTextureNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TextureSet instance;
try
{
int UtcDaliTextureSetGetTextureCountNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TextureSet instance;
try
{
}
END_TEST;
}
+
+int UtcDaliTextureSetMultipleTextures(void)
+{
+ TestApplication application;
+
+ Shader shader = CreateShader();
+ TextureSet textureSet = CreateTextureSet();
+
+ // Set 2 textures
+ Texture texture1 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
+ textureSet.SetTexture(0u, texture1);
+
+ Texture texture2 = Texture::New(TextureType::TEXTURE_2D, Pixel::RGBA8888, 64, 64);
+ textureSet.SetTexture(1u, texture2);
+
+ Geometry geometry = CreateQuadGeometry();
+ Renderer renderer = Renderer::New(geometry, shader);
+ renderer.SetTextures(textureSet);
+
+ Actor actor = Actor::New();
+ actor.AddRenderer(renderer);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(400.0f, 400.0f));
+
+ application.GetScene().Add(actor);
+
+ application.SendNotification();
+ application.Render();
+
+ const std::vector<GLuint>& boundTextures0 = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE0);
+ DALI_TEST_CHECK(boundTextures0[boundTextures0.size() - 1] == 1u); // the latest one should be 0.
+
+ const std::vector<GLuint>& boundTextures1 = application.GetGlAbstraction().GetBoundTextures(GL_TEXTURE1);
+ size_t count = boundTextures1.size();
+ DALI_TEST_CHECK(boundTextures1[count - 1] == 2u); // the latest one should be 1.
+
+ // Create a new TextureSet
+ textureSet = CreateTextureSet();
+
+ // Set 1 texture
+ textureSet.SetTexture(0u, texture1);
+
+ renderer.SetTextures(textureSet);
+
+ application.SendNotification();
+ application.Render();
+
+ TestGlAbstraction& gl = application.GetGlAbstraction();
+ DALI_TEST_CHECK(gl.GetActiveTextureUnit() == GL_TEXTURE0);
+
+ DALI_TEST_CHECK(boundTextures0[boundTextures0.size() - 1] == 1u);
+ DALI_TEST_CHECK(boundTextures1.size() == count); // The bound texture count of GL_TEXTURE1 should not be changed.
+
+ END_TEST;
+}
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <dali-test-suite-utils.h>
+#include <dali/devel-api/threading/thread.h>
#include <stdlib.h>
#include <unistd.h>
+
+#include <iostream>
#include <type_traits>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/threading/thread.h>
using Dali::Thread;
gRunThreadEntryFunc = true;
}
};
-}
+} // namespace
int UtcDaliThreadP(void)
{
thread.Start();
// wait till the thread is terminated
- while( !gRunThreadEntryFunc )
+ while(!gRunThreadEntryFunc)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
- DALI_TEST_EQUALS( true, gRunThreadEntryFunc, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, gRunThreadEntryFunc, TEST_LOCATION);
thread.Join();
thread.Start();
thread.Join();
// wait till the thread is terminated
- while( !gRunThreadEntryFunc )
+ while(!gRunThreadEntryFunc)
{
- usleep( 1 ); // 1 microsecond
+ usleep(1); // 1 microsecond
}
- DALI_TEST_EQUALS( true, gRunThreadEntryFunc, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, gRunThreadEntryFunc, TEST_LOCATION);
END_TEST;
}
{
// we want to make sure that mutex is not copyable (its copy constructor is not defined)
// this test will stop compiling if Mutex has compiler generated copy constructor
- static_assert( !__has_trivial_copy( Thread ), "Thread should NOT be copyable" );
+ static_assert(!__has_trivial_copy(Thread), "Thread should NOT be copyable");
- DALI_TEST_CHECK( true );
+ DALI_TEST_CHECK(true);
END_TEST;
}
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <dali-test-suite-utils.h>
+#include <dali/devel-api/threading/thread-pool.h>
#include <stdlib.h>
#include <unistd.h>
+
+#include <iostream>
#include <type_traits>
-#include <dali-test-suite-utils.h>
-#include <dali/devel-api/threading/thread-pool.h>
namespace
{
// Helper function dividing workload into N batches
// the loop lambda contains
-Dali::UniqueFutureGroup ForEachMT( Dali::ThreadPool* pThreadPool,
- uint32_t first,
- uint32_t size,
- std::function<void( uint32_t, uint32_t, uint32_t )> task )
+Dali::UniqueFutureGroup ForEachMT(Dali::ThreadPool* pThreadPool,
+ uint32_t first,
+ uint32_t size,
+ std::function<void(uint32_t, uint32_t, uint32_t)> task)
{
- uint32_t i = 0;
- uint32_t j = 0;
+ uint32_t i = 0;
+ uint32_t j = 0;
const auto workerCount = uint32_t(pThreadPool->GetWorkerCount());
- const auto step = size / workerCount;
- j = workerCount + step;
+ const auto step = size / workerCount;
+ j = workerCount + step;
std::vector<Dali::Task> tasks;
- tasks.reserve( workerCount );
+ tasks.reserve(workerCount);
- for( auto threadIndex = 0u; threadIndex < workerCount; ++threadIndex )
+ for(auto threadIndex = 0u; threadIndex < workerCount; ++threadIndex)
{
- Dali::Task lambda = [task, i, j]( int workerIndex )
- {
- task( uint32_t(workerIndex), i, j );
+ Dali::Task lambda = [task, i, j](int workerIndex) {
+ task(uint32_t(workerIndex), i, j);
};
- tasks.emplace_back( lambda );
+ tasks.emplace_back(lambda);
i = j;
j = i + step;
- if( j > size )
+ if(j > size)
j = size;
}
- return pThreadPool->SubmitTasks( tasks, workerCount );
+ return pThreadPool->SubmitTasks(tasks, workerCount);
}
-}
+} // namespace
int UtcDaliThreadPoolMultipleTasks(void)
{
// initialise global thread pool
- if( !gThreadPool.GetWorkerCount() )
+ if(!gThreadPool.GetWorkerCount())
{
- gThreadPool.Initialize( 0u );
+ gThreadPool.Initialize(0u);
}
// populate inputs
std::array<int, 8192> inputs;
- int checksum = 0;
- for( auto i = 0; i < decltype(i)(inputs.size()); ++i )
+ int checksum = 0;
+ for(auto i = 0; i < decltype(i)(inputs.size()); ++i)
{
inputs[i] = i;
checksum += i;
auto workerCount = gThreadPool.GetWorkerCount();
std::vector<int> outputs;
- outputs.resize( workerCount );
- std::fill( outputs.begin(), outputs.end(), 0 );
+ outputs.resize(workerCount);
+ std::fill(outputs.begin(), outputs.end(), 0);
// submit
- auto future = ForEachMT( &gThreadPool, 0, inputs.size(), [&inputs, &outputs]( uint32_t workerIndex, uint32_t begin, uint32_t end )
- {
- for( auto i = begin; i < end; ++i )
+ auto future = ForEachMT(&gThreadPool, 0, inputs.size(), [&inputs, &outputs](uint32_t workerIndex, uint32_t begin, uint32_t end) {
+ for(auto i = begin; i < end; ++i)
{
outputs[workerIndex] += inputs[i];
}
// check outputs
int checksum2 = 0;
- for( auto output : outputs )
+ for(auto output : outputs)
{
checksum2 += output;
}
printf("sum: %d, sum2: %d\n", checksum, checksum2);
-
- DALI_TEST_EQUALS( checksum, checksum2, TEST_LOCATION );
+ DALI_TEST_EQUALS(checksum, checksum2, TEST_LOCATION);
END_TEST;
}
int UtcDaliThreadPoolSingleTask(void)
{
// initialise global thread pool
- if( !gThreadPool.GetWorkerCount() )
+ if(!gThreadPool.GetWorkerCount())
{
- gThreadPool.Initialize( 0u );
+ gThreadPool.Initialize(0u);
}
// some long lasting task
- int counter = 0;
- auto task = [&counter]( int workerIndex ){
- for( int i = 0; i < 10; ++i )
+ int counter = 0;
+ auto task = [&counter](int workerIndex) {
+ for(int i = 0; i < 10; ++i)
{
counter++;
- usleep( 16 * 1000 );
+ usleep(16 * 1000);
}
};
- auto future = gThreadPool.SubmitTask( 0, task );
+ auto future = gThreadPool.SubmitTask(0, task);
future->Wait();
- DALI_TEST_EQUALS( counter, 10, TEST_LOCATION );
+ DALI_TEST_EQUALS(counter, 10, TEST_LOCATION);
END_TEST;
}
int UtcDaliThreadPoolSubmitTasksCopyArray(void)
{
// initialise global thread pool
- if( !gThreadPool.GetWorkerCount() )
+ if(!gThreadPool.GetWorkerCount())
{
- gThreadPool.Initialize( 0u );
+ gThreadPool.Initialize(0u);
}
- std::array<uint8_t, 1024*1024> dataSrc;
- for( auto i = 0; i < decltype(i)(dataSrc.size()); ++i)
+ std::array<uint8_t, 1024 * 1024> dataSrc;
+ for(auto i = 0; i < decltype(i)(dataSrc.size()); ++i)
{
dataSrc[i] = (std::rand() % 0xff);
}
- std::array<uint8_t, 1024*1024> dataDst;
+ std::array<uint8_t, 1024 * 1024> dataDst;
// each task copies 1kb od data
std::vector<Dali::Task> tasks;
- for( int i = 0; i < 1024; ++i )
+ for(int i = 0; i < 1024; ++i)
{
- auto task = [&dataSrc, &dataDst, i ]( int workerIndex )
- {
- for( int k = 0; k < 1024; ++k )
+ auto task = [&dataSrc, &dataDst, i](int workerIndex) {
+ for(int k = 0; k < 1024; ++k)
{
- dataDst[i*1024+k] = dataSrc[i*1024+k];
+ dataDst[i * 1024 + k] = dataSrc[i * 1024 + k];
}
};
- tasks.push_back( task );
+ tasks.push_back(task);
}
- DALI_TEST_EQUALS( 1024, tasks.size(), TEST_LOCATION );
+ DALI_TEST_EQUALS(1024, tasks.size(), TEST_LOCATION);
- gThreadPool.SubmitTasks( tasks );
+ gThreadPool.SubmitTasks(tasks);
// wait for pool to finish
gThreadPool.Wait();
// compare arrays
- for( auto i = 0; i < decltype(i)(dataSrc.size()); ++i )
+ for(auto i = 0; i < decltype(i)(dataSrc.size()); ++i)
{
- DALI_TEST_EQUALS( dataSrc[i], dataDst[i], TEST_LOCATION );
- if( dataSrc[i] != dataDst[i] )
+ DALI_TEST_EQUALS(dataSrc[i], dataDst[i], TEST_LOCATION);
+ if(dataSrc[i] != dataDst[i])
{
break;
}
*
*/
-#include <iostream>
+#include <dali-test-suite-utils.h>
+#include <dali/integration-api/events/touch-integ.h>
+#include <dali/public-api/dali-core.h>
#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/events/touch-integ.h>
-#include <dali-test-suite-utils.h>
+#include <iostream>
void utc_dali_touch_event_startup(void)
{
{
return TouchPoint(1, PointState::STARTED, 100.0f, 200.0f);
}
-}
+} // namespace
int UtcDaliTouchEventConstructorP(void)
{
TouchEvent touchEvent;
- DALI_TEST_CHECK( !touchEvent );
+ DALI_TEST_CHECK(!touchEvent);
END_TEST;
}
int UtcDaliTouchEventCopyConstructorP(void)
{
TouchEvent touchEvent = Integration::NewTouchEvent(123u, GenerateTouchPoint());
- DALI_TEST_CHECK( touchEvent );
+ DALI_TEST_CHECK(touchEvent);
const auto refCount = touchEvent.GetBaseObject().ReferenceCount();
- TouchEvent touchEvent2( touchEvent );
- DALI_TEST_CHECK( touchEvent );
- DALI_TEST_CHECK( touchEvent2 );
- DALI_TEST_EQUALS( touchEvent, touchEvent2, TEST_LOCATION );
- DALI_TEST_EQUALS( refCount + 1, touchEvent.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ TouchEvent touchEvent2(touchEvent);
+ DALI_TEST_CHECK(touchEvent);
+ DALI_TEST_CHECK(touchEvent2);
+ DALI_TEST_EQUALS(touchEvent, touchEvent2, TEST_LOCATION);
+ DALI_TEST_EQUALS(refCount + 1, touchEvent.GetBaseObject().ReferenceCount(), TEST_LOCATION);
END_TEST;
}
int UtcDaliTouchEventMoveConstructorP(void)
{
TouchEvent touchEvent = Integration::NewTouchEvent(123u, GenerateTouchPoint());
- DALI_TEST_CHECK( touchEvent );
+ DALI_TEST_CHECK(touchEvent);
const auto refCount = touchEvent.GetBaseObject().ReferenceCount();
- TouchEvent touchEvent2( std::move(touchEvent) );
- DALI_TEST_CHECK( !touchEvent );
- DALI_TEST_CHECK( touchEvent2 );
- DALI_TEST_EQUALS( refCount, touchEvent2.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ TouchEvent touchEvent2(std::move(touchEvent));
+ DALI_TEST_CHECK(!touchEvent);
+ DALI_TEST_CHECK(touchEvent2);
+ DALI_TEST_EQUALS(refCount, touchEvent2.GetBaseObject().ReferenceCount(), TEST_LOCATION);
END_TEST;
}
int UtcDaliTouchEventCopyAssignmentP(void)
{
TouchEvent touchEvent = Integration::NewTouchEvent(123u, GenerateTouchPoint());
- DALI_TEST_CHECK( touchEvent );
+ DALI_TEST_CHECK(touchEvent);
const auto refCount = touchEvent.GetBaseObject().ReferenceCount();
TouchEvent touchEvent2;
- DALI_TEST_CHECK( !touchEvent2 );
+ DALI_TEST_CHECK(!touchEvent2);
touchEvent2 = touchEvent;
- DALI_TEST_CHECK( touchEvent );
- DALI_TEST_CHECK( touchEvent2 );
- DALI_TEST_EQUALS( touchEvent, touchEvent2, TEST_LOCATION );
- DALI_TEST_EQUALS( refCount + 1, touchEvent.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(touchEvent);
+ DALI_TEST_CHECK(touchEvent2);
+ DALI_TEST_EQUALS(touchEvent, touchEvent2, TEST_LOCATION);
+ DALI_TEST_EQUALS(refCount + 1, touchEvent.GetBaseObject().ReferenceCount(), TEST_LOCATION);
END_TEST;
}
int UtcDaliTouchEventMoveAssignmentP(void)
{
TouchEvent touchEvent = Integration::NewTouchEvent(123u, GenerateTouchPoint());
- DALI_TEST_CHECK( touchEvent );
+ DALI_TEST_CHECK(touchEvent);
const auto refCount = touchEvent.GetBaseObject().ReferenceCount();
TouchEvent touchEvent2;
- DALI_TEST_CHECK( !touchEvent2 );
+ DALI_TEST_CHECK(!touchEvent2);
touchEvent2 = std::move(touchEvent);
- DALI_TEST_CHECK( !touchEvent );
- DALI_TEST_CHECK( touchEvent2 );
- DALI_TEST_EQUALS( refCount, touchEvent2.GetBaseObject().ReferenceCount(), TEST_LOCATION );
+ DALI_TEST_CHECK(!touchEvent);
+ DALI_TEST_CHECK(touchEvent2);
+ DALI_TEST_EQUALS(refCount, touchEvent2.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliTouchEventCopyConstructorWithPointP(void)
+{
+ Dali::Integration::Point point;
+
+ Vector2 touchPoint(10.0, 20.0);
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(touchPoint.x, touchPoint.y));
+
+ TouchEvent touchEvent = Integration::NewTouchEvent(123u, point);
+ DALI_TEST_CHECK(touchEvent);
+
+ const auto refCount = touchEvent.GetBaseObject().ReferenceCount();
+
+ TouchEvent touchEvent2(touchEvent);
+ DALI_TEST_CHECK(touchEvent);
+ DALI_TEST_CHECK(touchEvent2);
+ DALI_TEST_EQUALS(touchEvent, touchEvent2, TEST_LOCATION);
+ DALI_TEST_EQUALS(refCount + 1, touchEvent.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+
+ END_TEST;
+}
+
+int UtcDaliTouchEventMoveConstructorWithPointP(void)
+{
+ Dali::Integration::Point point;
+
+ Vector2 touchPoint(10.0, 20.0);
+ point.SetDeviceId(1);
+ point.SetState(PointState::DOWN);
+ point.SetScreenPosition(Vector2(touchPoint.x, touchPoint.y));
+
+ TouchEvent touchEvent = Integration::NewTouchEvent(123u, point);
+ DALI_TEST_CHECK(touchEvent);
+
+ const auto refCount = touchEvent.GetBaseObject().ReferenceCount();
+
+ TouchEvent touchEvent2(std::move(touchEvent));
+ DALI_TEST_CHECK(!touchEvent);
+ DALI_TEST_CHECK(touchEvent2);
+ DALI_TEST_EQUALS(refCount, touchEvent2.GetBaseObject().ReferenceCount(), TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
+#include <dali-test-suite-utils.h>
+#include <dali/integration-api/events/hover-event-integ.h>
#include <dali/integration-api/events/touch-event-combiner.h>
#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/events/hover-event-integ.h>
-#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
using namespace Dali::Integration;
namespace
{
-Point GeneratePoint( int deviceId, PointState::Type state, float x, float y )
+Point GeneratePoint(int deviceId, PointState::Type state, float x, float y)
{
Point point;
- point.SetDeviceId( deviceId );
- point.SetState( state );
- point.SetScreenPosition( Vector2( x, y ) );
+ point.SetDeviceId(deviceId);
+ point.SetState(state);
+ point.SetScreenPosition(Vector2(x, y));
return point;
}
-}
+} // namespace
void utc_dali_touch_event_combiner_startup(void)
{
test_return_value = TET_PASS;
}
-
int UtcDaliTouchEventCombinerConstructors(void)
{
TouchEventCombiner combiner1;
- DALI_TEST_EQUALS( combiner1.GetMinimumMotionTimeThreshold(), static_cast<long unsigned>(1), TEST_LOCATION );
- DALI_TEST_EQUALS( combiner1.GetMinimumMotionDistanceThreshold(), Vector2( 1.0f, 1.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(combiner1.GetMinimumMotionTimeThreshold(), static_cast<long unsigned>(1), TEST_LOCATION);
+ DALI_TEST_EQUALS(combiner1.GetMinimumMotionDistanceThreshold(), Vector2(1.0f, 1.0f), TEST_LOCATION);
- TouchEventCombiner combiner2( 10, 20.0f, 31.0f );
- DALI_TEST_EQUALS( combiner2.GetMinimumMotionTimeThreshold(), static_cast<long unsigned>(10), TEST_LOCATION );
- DALI_TEST_EQUALS( combiner2.GetMinimumMotionDistanceThreshold(), Vector2( 20.0f, 31.0f ), TEST_LOCATION );
+ TouchEventCombiner combiner2(10, 20.0f, 31.0f);
+ DALI_TEST_EQUALS(combiner2.GetMinimumMotionTimeThreshold(), static_cast<long unsigned>(10), TEST_LOCATION);
+ DALI_TEST_EQUALS(combiner2.GetMinimumMotionDistanceThreshold(), Vector2(20.0f, 31.0f), TEST_LOCATION);
- TouchEventCombiner combiner3( 10, Vector2( 20.0f, 31.0f ) );
- DALI_TEST_EQUALS( combiner3.GetMinimumMotionTimeThreshold(), static_cast<long unsigned>(10), TEST_LOCATION );
- DALI_TEST_EQUALS( combiner3.GetMinimumMotionDistanceThreshold(), Vector2( 20.0f, 31.0f ), TEST_LOCATION );
+ TouchEventCombiner combiner3(10, Vector2(20.0f, 31.0f));
+ DALI_TEST_EQUALS(combiner3.GetMinimumMotionTimeThreshold(), static_cast<long unsigned>(10), TEST_LOCATION);
+ DALI_TEST_EQUALS(combiner3.GetMinimumMotionDistanceThreshold(), Vector2(20.0f, 31.0f), TEST_LOCATION);
// Boundary Checks
- TouchEventCombiner combiner4( 10, 0.0f, 0.0f );
- DALI_TEST_EQUALS( combiner4.GetMinimumMotionDistanceThreshold(), Vector2( 0.0f, 0.0f ), TEST_LOCATION );
+ TouchEventCombiner combiner4(10, 0.0f, 0.0f);
+ DALI_TEST_EQUALS(combiner4.GetMinimumMotionDistanceThreshold(), Vector2(0.0f, 0.0f), TEST_LOCATION);
- TouchEventCombiner combiner5( 10, Vector2( 0.0f, 0.0f ) );
- DALI_TEST_EQUALS( combiner5.GetMinimumMotionDistanceThreshold(), Vector2( 0.0f, 0.0f ), TEST_LOCATION );
+ TouchEventCombiner combiner5(10, Vector2(0.0f, 0.0f));
+ DALI_TEST_EQUALS(combiner5.GetMinimumMotionDistanceThreshold(), Vector2(0.0f, 0.0f), TEST_LOCATION);
END_TEST;
}
{
try
{
- TouchEventCombiner combiner( 10, -20.0f, 31.0f );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ TouchEventCombiner combiner(10, -20.0f, 31.0f);
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- TouchEventCombiner combiner( 10, 20.0f, -31.0f );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ TouchEventCombiner combiner(10, 20.0f, -31.0f);
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- TouchEventCombiner combiner( 10, Vector2( -20.0f, 31.0f ) );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ TouchEventCombiner combiner(10, Vector2(-20.0f, 31.0f));
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- TouchEventCombiner combiner( 10, Vector2( 20.0f, -31.0f ) );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ TouchEventCombiner combiner(10, Vector2(20.0f, -31.0f));
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSettersAndGetters(void)
{
TouchEventCombiner combiner;
- unsigned long time( 10u );
- Vector2 distance( 40.0f, 30.0f );
+ unsigned long time(10u);
+ Vector2 distance(40.0f, 30.0f);
- DALI_TEST_CHECK( combiner.GetMinimumMotionTimeThreshold() != time );
- DALI_TEST_CHECK( combiner.GetMinimumMotionDistanceThreshold() != distance );
+ DALI_TEST_CHECK(combiner.GetMinimumMotionTimeThreshold() != time);
+ DALI_TEST_CHECK(combiner.GetMinimumMotionDistanceThreshold() != distance);
- combiner.SetMinimumMotionTimeThreshold( time );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionTimeThreshold(), time, TEST_LOCATION );
+ combiner.SetMinimumMotionTimeThreshold(time);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionTimeThreshold(), time, TEST_LOCATION);
- combiner.SetMinimumMotionDistanceThreshold( distance.x );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionDistanceThreshold(), Vector2( distance.x, distance.x ), TEST_LOCATION );
+ combiner.SetMinimumMotionDistanceThreshold(distance.x);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionDistanceThreshold(), Vector2(distance.x, distance.x), TEST_LOCATION);
distance.x = 20.0f;
distance.y = 50.0f;
- combiner.SetMinimumMotionDistanceThreshold( distance.x, distance.y );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionDistanceThreshold(), distance, TEST_LOCATION );
+ combiner.SetMinimumMotionDistanceThreshold(distance.x, distance.y);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionDistanceThreshold(), distance, TEST_LOCATION);
distance.x = 100.0f;
distance.y = 20.0f;
- combiner.SetMinimumMotionDistanceThreshold( distance );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionDistanceThreshold(), distance, TEST_LOCATION );
+ combiner.SetMinimumMotionDistanceThreshold(distance);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionDistanceThreshold(), distance, TEST_LOCATION);
// Boundary Checks
- combiner.SetMinimumMotionDistanceThreshold( 0.0f );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionDistanceThreshold(), Vector2::ZERO, TEST_LOCATION );
+ combiner.SetMinimumMotionDistanceThreshold(0.0f);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionDistanceThreshold(), Vector2::ZERO, TEST_LOCATION);
- combiner.SetMinimumMotionDistanceThreshold( 0.0f, 0.0f );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionDistanceThreshold(), Vector2::ZERO, TEST_LOCATION );
+ combiner.SetMinimumMotionDistanceThreshold(0.0f, 0.0f);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionDistanceThreshold(), Vector2::ZERO, TEST_LOCATION);
- combiner.SetMinimumMotionDistanceThreshold( Vector2::ZERO );
- DALI_TEST_EQUALS( combiner.GetMinimumMotionDistanceThreshold(), Vector2::ZERO, TEST_LOCATION );
+ combiner.SetMinimumMotionDistanceThreshold(Vector2::ZERO);
+ DALI_TEST_EQUALS(combiner.GetMinimumMotionDistanceThreshold(), Vector2::ZERO, TEST_LOCATION);
END_TEST;
}
try
{
- combiner.SetMinimumMotionDistanceThreshold( -100.0f );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ combiner.SetMinimumMotionDistanceThreshold(-100.0f);
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- combiner.SetMinimumMotionDistanceThreshold( -100.0f, 20.0f );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ combiner.SetMinimumMotionDistanceThreshold(-100.0f, 20.0f);
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- combiner.SetMinimumMotionDistanceThreshold( 100.0f, -20.0f );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ combiner.SetMinimumMotionDistanceThreshold(100.0f, -20.0f);
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- combiner.SetMinimumMotionDistanceThreshold( Vector2( -100.0f, 20.0f ) );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ combiner.SetMinimumMotionDistanceThreshold(Vector2(-100.0f, 20.0f));
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
try
{
- combiner.SetMinimumMotionDistanceThreshold( Vector2( 100.0f, -20.0f ) );
- tet_printf( "%s: Should have asserted\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ combiner.SetMinimumMotionDistanceThreshold(Vector2(100.0f, -20.0f));
+ tet_printf("%s: Should have asserted\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- tet_result( TET_PASS );
+ tet_result(TET_PASS);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchNormal(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 101.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 101.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 101.0f, 101.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 101.0f, 101.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
// Motion event, but same time
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
// Up event, no time diff, no movement
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchMotionWithoutDown(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Motion event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), PointState::STARTED, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), PointState::STARTED, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchMotionFollowedByDown(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Motion event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), PointState::STARTED, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), PointState::STARTED, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 103.0f, 103.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 103.0f, 103.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 103.0f, 103.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 103.0f, 103.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_BOTH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), PointState::FINISHED, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_BOTH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), PointState::FINISHED, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchTwoDowns(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchUpWithoutDown(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Up event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchTwoUps(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchUpWithDifferentId(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(2, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchMotionWithDifferentId(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::MOTION, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(2, PointState::MOTION, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), PointState::STARTED, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_HOVER, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), PointState::STARTED, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 102.0f, 102.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 102.0f, 102.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerMultiTouchNormal(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// 1st point down
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::DOWN, 200.0f, 200.0f );
+ Integration::Point point = GeneratePoint(2, PointState::DOWN, 200.0f, 200.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), PointState::STATIONARY, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), PointState::STATIONARY, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::MOTION, 101.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::MOTION, 101.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetState(), PointState::STATIONARY, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetState(), PointState::STATIONARY, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
// 2nd point motion, no time diff
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::MOTION, 200.0f, 200.0f );
+ Integration::Point point = GeneratePoint(2, PointState::MOTION, 200.0f, 200.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::MOTION, 201.0f, 201.0f );
+ Integration::Point point = GeneratePoint(2, PointState::MOTION, 201.0f, 201.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), PointState::STATIONARY, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), PointState::STATIONARY, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 101.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 101.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 2u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[1].GetState(), PointState::STATIONARY, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 2u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[1].GetState(), PointState::STATIONARY, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::MOTION, 202.0f, 202.0f );
+ Integration::Point point = GeneratePoint(2, PointState::MOTION, 202.0f, 202.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 2, PointState::UP, 202.0f, 202.0f );
+ Integration::Point point = GeneratePoint(2, PointState::UP, 202.0f, 202.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSeveralPoints(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
- unsigned int const maximum( 200u );
+ unsigned long time(0u);
+ unsigned int const maximum(200u);
// Several downs
- for ( unsigned int pointCount = 1u; pointCount < maximum; ++pointCount )
+ for(unsigned int pointCount = 1u; pointCount < maximum; ++pointCount)
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( pointCount, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(pointCount, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time++, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), pointCount, TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time++, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), pointCount, TEST_LOCATION);
}
// Several Ups
- for ( unsigned int pointCount = maximum - 1; pointCount > 0; --pointCount )
+ for(unsigned int pointCount = maximum - 1; pointCount > 0; --pointCount)
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( pointCount, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(pointCount, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time++, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), pointCount, TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time++, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), pointCount, TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerReset(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerSingleTouchInterrupted(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Down event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetDeviceId(), point.GetDeviceId(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetScreenPosition(), point.GetScreenPosition(), TEST_LOCATION);
}
time++;
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::INTERRUPTED, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::INTERRUPTED, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_BOTH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_BOTH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
}
// Send up, should not be able to send as combiner has been reset.
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerMultiTouchInterrupted(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
- unsigned int const maximum( 200u );
+ unsigned long time(0u);
+ unsigned int const maximum(200u);
// Several downs
- for ( unsigned int pointCount = 1u; pointCount < maximum; ++pointCount )
+ for(unsigned int pointCount = 1u; pointCount < maximum; ++pointCount)
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( pointCount, PointState::DOWN, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(pointCount, PointState::DOWN, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), pointCount, TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_TOUCH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), pointCount, TEST_LOCATION);
}
// Interrupted event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::INTERRUPTED, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::INTERRUPTED, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_BOTH, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.GetPointCount(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_BOTH, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.GetPointCount(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(hoverEvent.points[0].GetState(), point.GetState(), TEST_LOCATION);
}
// Send up, should not be able to send as combiner has been reset.
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::UP, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::UP, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
int UtcDaliTouchEventCombinerInvalidState(void)
{
TouchEventCombiner combiner;
- unsigned long time( 0u );
+ unsigned long time(0u);
// Stationary event
{
Integration::TouchEvent touchEvent;
Integration::HoverEvent hoverEvent;
- Integration::Point point = GeneratePoint( 1, PointState::STATIONARY, 100.0f, 100.0f );
+ Integration::Point point = GeneratePoint(1, PointState::STATIONARY, 100.0f, 100.0f);
- DALI_TEST_EQUALS( Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent( point, time, touchEvent, hoverEvent ), TEST_LOCATION );
+ DALI_TEST_EQUALS(Integration::TouchEventCombiner::DISPATCH_NONE, combiner.GetNextTouchEvent(point, time, touchEvent, hoverEvent), TEST_LOCATION);
}
END_TEST;
}
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/events/touch-integ.h>
-#include <dali/integration-api/events/touch-event-integ.h>
-#include <dali/integration-api/render-task-list-integ.h>
#include <dali-test-suite-utils.h>
#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/integration-api/events/touch-integ.h>
+#include <dali/integration-api/render-task-list-integ.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
{
struct TestPoint
{
- int32_t deviceId{-1};
- PointState::Type state{PointState::FINISHED};
- Actor hitActor;
- Vector2 local;
- Vector2 screen;
- float radius{0};
- Vector2 ellipseRadius;
- float pressure{0};
- Degree angle;
- Device::Class::Type deviceClass{Device::Class::NONE};
+ int32_t deviceId{-1};
+ PointState::Type state{PointState::FINISHED};
+ Actor hitActor;
+ Vector2 local;
+ Vector2 screen;
+ float radius{0};
+ Vector2 ellipseRadius;
+ float pressure{0};
+ Degree angle;
+ Device::Class::Type deviceClass{Device::Class::NONE};
Device::Subclass::Type deviceSubclass{Device::Subclass::NONE};
TestPoint() = default;
const TestPoint TestPoint::ZERO;
-
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
SignalData()
- : functorCalled( false ),
+ : functorCalled(false),
receivedTouch(),
touchedActor()
{
struct TestTouchEvent
{
- unsigned long time;
+ unsigned long time;
std::vector<TestPoint> points;
const TestPoint& GetPoint(size_t i)
{
- if( i < points.size() )
+ if(i < points.size())
{
return points[i];
}
touchedActor.Reset();
}
- bool functorCalled;
+ bool functorCalled;
TestTouchEvent receivedTouch;
- Actor touchedActor;
+ Actor touchedActor;
};
// Functor that sets the data when called
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- TouchEventFunctor( SignalData& data, bool returnValue = true )
- : signalData( data ),
- returnValue( returnValue )
+ TouchEventFunctor(SignalData& data, bool returnValue = true)
+ : signalData(data),
+ returnValue(returnValue)
{
}
- bool operator()( Actor actor, const TouchEvent& touch )
+ bool operator()(Actor actor, const TouchEvent& touch)
{
signalData.functorCalled = true;
- signalData.touchedActor = actor;
+ signalData.touchedActor = actor;
signalData.receivedTouch.time = touch.GetTime();
signalData.receivedTouch.points.clear();
- for( size_t i=0; i<touch.GetPointCount(); ++i )
+ for(size_t i = 0; i < touch.GetPointCount(); ++i)
{
TestPoint p;
- p.deviceId = touch.GetDeviceId(i);
- p.state = touch.GetState(i);
- p.hitActor = touch.GetHitActor(i);
- p.local = touch.GetLocalPosition(i);
- p.screen = touch.GetScreenPosition(i);
- p.radius = touch.GetRadius(i);
- p.ellipseRadius = touch.GetEllipseRadius(i);
- p.pressure = touch.GetPressure(i);
- p.angle = touch.GetAngle(i);
- p.deviceClass = touch.GetDeviceClass(i);
+ p.deviceId = touch.GetDeviceId(i);
+ p.state = touch.GetState(i);
+ p.hitActor = touch.GetHitActor(i);
+ p.local = touch.GetLocalPosition(i);
+ p.screen = touch.GetScreenPosition(i);
+ p.radius = touch.GetRadius(i);
+ p.ellipseRadius = touch.GetEllipseRadius(i);
+ p.pressure = touch.GetPressure(i);
+ p.angle = touch.GetAngle(i);
+ p.deviceClass = touch.GetDeviceClass(i);
p.deviceSubclass = touch.GetDeviceSubclass(i);
signalData.receivedTouch.points.push_back(p);
}
}
SignalData& signalData;
- bool returnValue;
+ bool returnValue;
};
struct HandleData
{
- bool signalReceived;
+ bool signalReceived;
TouchEvent receivedTouchHandle;
HandleData()
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- TouchEventHandleFunctor( HandleData& handleData, bool returnValue = true )
+ TouchEventHandleFunctor(HandleData& handleData, bool returnValue = true)
: handleData(handleData),
- returnValue( returnValue )
+ returnValue(returnValue)
{
}
- bool operator()( Actor actor, const TouchEvent& someTouchEvent )
+ bool operator()(Actor actor, const TouchEvent& someTouchEvent)
{
- handleData.signalReceived = true;
+ handleData.signalReceived = true;
handleData.receivedTouchHandle = someTouchEvent;
return returnValue;
}
HandleData& handleData;
- bool returnValue;
+ bool returnValue;
};
-
// Functor that removes the actor when called.
struct RemoveActorFunctor : public TouchEventFunctor
{
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- RemoveActorFunctor( SignalData& data, bool returnValue = true )
- : TouchEventFunctor( data, returnValue )
+ RemoveActorFunctor(SignalData& data, bool returnValue = true)
+ : TouchEventFunctor(data, returnValue)
{
}
- bool operator()( Actor actor, const TouchEvent& touch )
+ bool operator()(Actor actor, const TouchEvent& touch)
{
- Actor parent( actor.GetParent() );
- if ( parent )
+ Actor parent(actor.GetParent());
+ if(parent)
{
- parent.Remove( actor );
+ parent.Remove(actor);
}
- return TouchEventFunctor::operator()( actor, touch );
+ return TouchEventFunctor::operator()(actor, touch);
}
};
struct OutOfBoundsData
{
TestPoint point;
- bool functorCalled;
+ bool functorCalled;
OutOfBoundsData()
- :functorCalled(false)
+ : functorCalled(false)
{
}
};
* @param[in] data Reference to the data to store callback information.
* @param[in] returnValue What the functor should return.
*/
- OutOfBoundsFunctor( OutOfBoundsData& data, bool returnValue = true )
- : outOfBoundsData ( data ),
- returnValue( returnValue )
+ OutOfBoundsFunctor(OutOfBoundsData& data, bool returnValue = true)
+ : outOfBoundsData(data),
+ returnValue(returnValue)
{
}
- bool operator()( Actor actor, const TouchEvent& touch )
+ bool operator()(Actor actor, const TouchEvent& touch)
{
outOfBoundsData.functorCalled = true;
- size_t count = touch.GetPointCount();
+ size_t count = touch.GetPointCount();
// Read out of bounds data
- outOfBoundsData.point.deviceId = touch.GetDeviceId(count+1);
- outOfBoundsData.point.state = touch.GetState(count+1);
- outOfBoundsData.point.hitActor = touch.GetHitActor(count+1);
- outOfBoundsData.point.local = touch.GetLocalPosition(count+1);
- outOfBoundsData.point.screen = touch.GetScreenPosition(count+1);
+ outOfBoundsData.point.deviceId = touch.GetDeviceId(count + 1);
+ outOfBoundsData.point.state = touch.GetState(count + 1);
+ outOfBoundsData.point.hitActor = touch.GetHitActor(count + 1);
+ outOfBoundsData.point.local = touch.GetLocalPosition(count + 1);
+ outOfBoundsData.point.screen = touch.GetScreenPosition(count + 1);
return returnValue;
}
OutOfBoundsData& outOfBoundsData;
- bool returnValue;
+ bool returnValue;
};
-Integration::TouchEvent GenerateSingleTouch( PointState::Type state, const Vector2& screenPosition )
+Integration::TouchEvent GenerateSingleTouch(PointState::Type state, const Vector2& screenPosition)
{
Integration::TouchEvent touchEvent;
- Integration::Point point;
- point.SetState( state );
- point.SetScreenPosition( screenPosition );
- point.SetDeviceClass( Device::Class::TOUCH );
- point.SetDeviceSubclass( Device::Subclass::NONE );
- touchEvent.points.push_back( point );
+ Integration::Point point;
+ point.SetState(state);
+ point.SetScreenPosition(screenPosition);
+ point.SetDeviceClass(Device::Class::TOUCH);
+ point.SetDeviceSubclass(Device::Subclass::NONE);
+ touchEvent.points.push_back(point);
return touchEvent;
}
-} // anon namespace
+} // namespace
///////////////////////////////////////////////////////////////////////////////
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touch signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 localCoordinates;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- const TestPoint *point1 = &data.receivedTouch.GetPoint(0);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, point1->state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, point1->screen, TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, point1->local, 0.1f, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ const TestPoint* point1 = &data.receivedTouch.GetPoint(0);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, point1->state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, point1->screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, point1->local, 0.1f, TEST_LOCATION);
data.Reset();
// Emit a motion signal
screenCoordinates.x = screenCoordinates.y = 11.0f;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, screenCoordinates ) );
- const TestPoint *point2 = &data.receivedTouch.GetPoint(0);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, point2->state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, point2->screen, TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, point2->local, 0.1f, TEST_LOCATION );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, screenCoordinates));
+ const TestPoint* point2 = &data.receivedTouch.GetPoint(0);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, point2->state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, point2->screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, point2->local, 0.1f, TEST_LOCATION);
data.Reset();
// Emit an up signal
screenCoordinates.x = screenCoordinates.y = 12.0f;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, screenCoordinates ) );
- const TestPoint *point3 = &data.receivedTouch.GetPoint(0);
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::UP, point3->state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, point3->screen, TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, point3->local, 0.1f, TEST_LOCATION );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, screenCoordinates));
+ const TestPoint* point3 = &data.receivedTouch.GetPoint(0);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::UP, point3->state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, point3->screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, point3->local, 0.1f, TEST_LOCATION);
data.Reset();
// Emit a down signal where the actor is not present
screenCoordinates.x = screenCoordinates.y = 200.0f;
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliTouchEventNormalProcessing02(void)
{
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- HandleData handleData;
- TouchEventHandleFunctor functor( handleData );
- actor.TouchedSignal().Connect( &application, functor );
+ HandleData handleData;
+ TouchEventHandleFunctor functor(handleData);
+ actor.TouchedSignal().Connect(&application, functor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 localCoordinates;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( true, handleData.signalReceived, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, handleData.receivedTouchHandle.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, handleData.receivedTouchHandle.GetState(0), TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, handleData.receivedTouchHandle.GetScreenPosition(0), TEST_LOCATION );
- DALI_TEST_EQUALS( localCoordinates, handleData.receivedTouchHandle.GetLocalPosition(0), 0.1f, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(true, handleData.signalReceived, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, handleData.receivedTouchHandle.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, handleData.receivedTouchHandle.GetState(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, handleData.receivedTouchHandle.GetScreenPosition(0), TEST_LOCATION);
+ DALI_TEST_EQUALS(localCoordinates, handleData.receivedTouchHandle.GetLocalPosition(0), 0.1f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliTouchEventAPINegative(void)
{
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- OutOfBoundsData data;
- OutOfBoundsFunctor functor( data, true );
- actor.TouchedSignal().Connect( &application, functor );
+ OutOfBoundsData data;
+ OutOfBoundsFunctor functor(data, true);
+ actor.TouchedSignal().Connect(&application, functor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 localCoordinates;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( -1, data.point.deviceId, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::FINISHED, data.point.state, TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.point.screen, TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2::ZERO, data.point.local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( ! data.point.hitActor );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(-1, data.point.deviceId, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::FINISHED, data.point.state, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.point.screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2::ZERO, data.point.local, 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(!data.point.hitActor);
END_TEST;
}
-
int UtcDaliTouchEventOutsideCameraNearFarPlanes(void)
{
TestApplication application;
- Integration::Scene scene = application.GetScene();
- Vector2 sceneSize = scene.GetSize();
+ Integration::Scene scene = application.GetScene();
+ Vector2 sceneSize = scene.GetSize();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::CENTER);
- actor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER);
+ actor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
scene.Add(actor);
// Render and notify
application.Render();
// Get the camera's near and far planes
- RenderTaskList taskList = scene.GetRenderTaskList();
- Dali::RenderTask task = taskList.GetTask(0);
- CameraActor camera = task.GetCameraActor();
- float nearPlane = camera.GetNearClippingPlane();
- float farPlane = camera.GetFarClippingPlane();
+ RenderTaskList taskList = scene.GetRenderTaskList();
+ Dali::RenderTask task = taskList.GetTask(0);
+ CameraActor camera = task.GetCameraActor();
+ float nearPlane = camera.GetNearClippingPlane();
+ float farPlane = camera.GetFarClippingPlane();
// Calculate the current distance of the actor from the camera
float tanHalfFov = tanf(camera.GetFieldOfView() * 0.5f);
- float distance = (sceneSize.y * 0.5f) / tanHalfFov;
+ float distance = (sceneSize.y * 0.5f) / tanHalfFov;
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
- Vector2 screenCoordinates( sceneSize.x * 0.5f, sceneSize.y * 0.5f );
+ Vector2 screenCoordinates(sceneSize.x * 0.5f, sceneSize.y * 0.5f);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a down signal where actor is just at the camera's near plane
- actor.SetProperty( Actor::Property::POSITION_Z, distance - nearPlane);
+ actor.SetProperty(Actor::Property::POSITION_Z, distance - nearPlane);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a down signal where actor is closer than the camera's near plane
- actor.SetProperty( Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f);
+ actor.SetProperty(Actor::Property::POSITION_Z, (distance - nearPlane) + 1.0f);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a down signal where actor is just at the camera's far plane
- actor.SetProperty( Actor::Property::POSITION_Z, distance - farPlane);
+ actor.SetProperty(Actor::Property::POSITION_Z, distance - farPlane);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a down signal where actor is further than the camera's far plane
- actor.SetProperty( Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f);
+ actor.SetProperty(Actor::Property::POSITION_Z, (distance - farPlane) - 1.0f);
// Render and notify
application.SendNotification();
application.Render();
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
{
// Emit an empty TouchEvent
Integration::TouchEvent event;
- application.ProcessEvent( event );
- tet_result( TET_FAIL );
+ application.ProcessEvent(event);
+ tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_ASSERT( e, "!event.points.empty()", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "!event.points.empty()", TEST_LOCATION);
}
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
// Emit an interrupted signal, we should be signalled regardless of whether there is a hit or not.
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
// Emit another interrupted signal, our signal handler should not be called.
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
int UtcDaliTouchEventParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false);
+ actor.TouchedSignal().Connect(&application, functor);
// Connect to root actor's touched signal
- SignalData rootData;
- TouchEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.TouchedSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ TouchEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.TouchedSignal().Connect(&application, rootFunctor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 actorCoordinates, rootCoordinates;
- actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit a motion signal
screenCoordinates.x = screenCoordinates.y = 11.0f;
- actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit an up signal
screenCoordinates.x = screenCoordinates.y = 12.0f;
- actor.ScreenToLocal( actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, screenCoordinates ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, data.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::UP, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::UP, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ actor.ScreenToLocal(actorCoordinates.x, actorCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, screenCoordinates));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, data.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::UP, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::UP, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, data.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(actorCoordinates, data.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit a down signal where the actor is not present, will hit the root actor though
screenCoordinates.x = screenCoordinates.y = 200.0f;
- rootActor.ScreenToLocal( rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION );
- DALI_TEST_EQUALS( rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.receivedTouch.points[0].hitActor );
+ rootActor.ScreenToLocal(rootCoordinates.x, rootCoordinates.y, screenCoordinates.x, screenCoordinates.y);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, rootData.receivedTouch.GetPointCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(screenCoordinates, rootData.receivedTouch.points[0].screen, TEST_LOCATION);
+ DALI_TEST_EQUALS(rootCoordinates, rootData.receivedTouch.points[0].local, 0.1f, TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor);
END_TEST;
}
int UtcDaliTouchEventInterruptedParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false);
+ actor.TouchedSignal().Connect(&application, functor);
// Connect to root actor's touched signal
- SignalData rootData;
- TouchEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.TouchedSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ TouchEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.TouchedSignal().Connect(&application, rootFunctor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit an interrupted signal
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit another down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
rootData.Reset();
// Remove actor from scene
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
data.Reset();
rootData.Reset();
application.Render();
// Emit an interrupted signal, only root actor's signal should be called.
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f /* Outside actor */ ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f /* Outside actor */)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit another interrupted state, none of the signal's should be called.
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( false, rootData.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(false, rootData.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Set actor to require leave events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
// Emit a motion signal outside of actor, should be signalled with a Leave
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
// Another motion outside of actor, no signalling
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 201.0f, 201.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(201.0f, 201.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Another motion event inside actor, signalled with motion
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
// We do not want to listen to leave events anymore
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, false );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
// Another motion event outside of actor, no signalling
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliTouchEventLeaveParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false);
+ actor.TouchedSignal().Connect(&application, functor);
// Connect to root actor's touched signal
- SignalData rootData;
- TouchEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.TouchedSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ TouchEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.TouchedSignal().Connect(&application, rootFunctor);
// Set actor to require leave events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
- rootActor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
+ rootActor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Emit a motion signal outside of actor, should be signalled with a Leave
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Another motion outside of actor, only rootActor signalled
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 201.0f, 201.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(201.0f, 201.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// Another motion event inside actor, signalled with motion
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 10.0f, 10.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::MOTION, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
// We do not want to listen to leave events of actor anymore
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, false );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, false);
// Another motion event outside of root actor, only root signalled
- Vector2 sceneSize( application.GetScene().GetSize() );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( sceneSize.width + 10.0f, sceneSize.height + 10.0f )) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION );
+ Vector2 sceneSize(application.GetScene().GetSize());
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(sceneSize.width + 10.0f, sceneSize.height + 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, rootData.receivedTouch.points[0].state, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
// Change actor to insensitive
- actor.SetProperty( Actor::Property::SENSITIVE, false );
+ actor.SetProperty(Actor::Property::SENSITIVE, false);
// Emit a motion signal, signalled with an interrupted
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliTouchEventActorBecomesInsensitiveParentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false);
+ actor.TouchedSignal().Connect(&application, functor);
// Connect to root actor's touched signal
- SignalData rootData;
- TouchEventFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.TouchedSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ TouchEventFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.TouchedSignal().Connect(&application, rootFunctor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
data.Reset();
rootData.Reset();
application.Render();
// Make root actor insensitive
- rootActor.SetProperty( Actor::Property::SENSITIVE, false );
+ rootActor.SetProperty(Actor::Property::SENSITIVE, false);
// Emit a motion signal, signalled with an interrupted (should get interrupted even if within root actor)
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2 ( 200.0f, 200.0f )) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
END_TEST;
}
int UtcDaliTouchEventMultipleLayers(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
+ SignalData data;
+ TouchEventFunctor functor(data);
- Layer layer1 ( Layer::New() );
- layer1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer1 );
+ Layer layer1(Layer::New());
+ layer1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer1);
- Actor actor1 ( Actor::New() );
- actor1.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor1.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- actor1.SetProperty( Actor::Property::POSITION_Z, 1.0f ); // Should hit actor1 in this layer
- layer1.Add( actor1 );
+ Actor actor1(Actor::New());
+ actor1.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor1.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ actor1.SetProperty(Actor::Property::POSITION_Z, 1.0f); // Should hit actor1 in this layer
+ layer1.Add(actor1);
// Render and notify
application.SendNotification();
application.Render();
// Connect to layer1 and actor1
- layer1.TouchedSignal().Connect( &application, functor );
- actor1.TouchedSignal().Connect( &application, functor );
+ layer1.TouchedSignal().Connect(&application, functor);
+ actor1.TouchedSignal().Connect(&application, functor);
// Hit in hittable area, actor1 should be hit
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.touchedActor == actor1 );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.touchedActor == actor1);
data.Reset();
// Make layer1 insensitive, nothing should be hit
- layer1.SetProperty( Actor::Property::SENSITIVE, false );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ layer1.SetProperty(Actor::Property::SENSITIVE, false);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Make layer1 sensitive again, again actor1 will be hit
- layer1.SetProperty( Actor::Property::SENSITIVE, true );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.touchedActor == actor1 );
+ layer1.SetProperty(Actor::Property::SENSITIVE, true);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.touchedActor == actor1);
data.Reset();
// Make rootActor insensitive, nothing should be hit
- rootActor.SetProperty( Actor::Property::SENSITIVE, false );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ rootActor.SetProperty(Actor::Property::SENSITIVE, false);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Make rootActor sensitive
- rootActor.SetProperty( Actor::Property::SENSITIVE, true );
+ rootActor.SetProperty(Actor::Property::SENSITIVE, true);
// Add another layer
- Layer layer2 ( Layer::New() );
- layer2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- layer2.SetProperty( Actor::Property::POSITION_Z, 10.0f ); // Should hit layer2 in this layer rather than actor2
- application.GetScene().Add( layer2 );
+ Layer layer2(Layer::New());
+ layer2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ layer2.SetProperty(Actor::Property::POSITION_Z, 10.0f); // Should hit layer2 in this layer rather than actor2
+ application.GetScene().Add(layer2);
- Actor actor2 ( Actor::New() );
- actor2.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor2.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- layer2.Add( actor2 );
+ Actor actor2(Actor::New());
+ actor2.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor2.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ layer2.Add(actor2);
// Render and notify
application.SendNotification();
application.Render();
// Connect to layer2 and actor2
- layer2.TouchedSignal().Connect( &application, functor );
- actor2.TouchedSignal().Connect( &application, functor );
+ layer2.TouchedSignal().Connect(&application, functor);
+ actor2.TouchedSignal().Connect(&application, functor);
// Emit an event, should hit layer2
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
//DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
data.Reset();
// Make layer2 insensitive, should hit actor1
- layer2.SetProperty( Actor::Property::SENSITIVE, false );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.touchedActor == actor1 );
+ layer2.SetProperty(Actor::Property::SENSITIVE, false);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.touchedActor == actor1);
data.Reset();
// Make layer2 sensitive again, should hit layer2
- layer2.SetProperty( Actor::Property::SENSITIVE, true );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ layer2.SetProperty(Actor::Property::SENSITIVE, true);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
//DALI_TEST_CHECK( data.touchedActor == layer2 ); // TODO: Uncomment this after removing renderable hack!
data.Reset();
// Make layer2 invisible, render and notify
- layer2.SetProperty( Actor::Property::VISIBLE, false );
+ layer2.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render();
// Should hit actor1
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( data.touchedActor == actor1 );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(data.touchedActor == actor1);
data.Reset();
// Make rootActor invisible, render and notify
- rootActor.SetProperty( Actor::Property::VISIBLE, false );
+ rootActor.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render();
// Should not hit anything
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliTouchEventMultipleRenderTasks(void)
{
- TestApplication application;
- Integration::Scene scene ( application.GetScene() );
- Vector2 sceneSize ( scene.GetSize() );
+ TestApplication application;
+ Integration::Scene scene(application.GetScene());
+ Vector2 sceneSize(scene.GetSize());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
scene.Add(actor);
// Create render task
- Viewport viewport( sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f );
- RenderTask renderTask ( application.GetScene().GetRenderTaskList().CreateTask() );
- renderTask.SetViewport( viewport );
- renderTask.SetInputEnabled( true );
+ Viewport viewport(sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f);
+ RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask());
+ renderTask.SetViewport(viewport);
+ renderTask.SetInputEnabled(true);
// Render and notify
application.SendNotification();
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Ensure renderTask actor can be hit too.
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Disable input on renderTask, should not be hittable
- renderTask.SetInputEnabled( false );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ renderTask.SetInputEnabled(false);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliTouchEventMultipleRenderTasksWithChildLayer(void)
{
- TestApplication application;
- Integration::Scene scene ( application.GetScene() );
- Vector2 sceneSize ( scene.GetSize() );
+ TestApplication application;
+ Integration::Scene scene(application.GetScene());
+ Vector2 sceneSize(scene.GetSize());
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
scene.Add(actor);
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
actor.Add(layer);
// Create render task
- Viewport viewport( sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f );
- RenderTask renderTask ( application.GetScene().GetRenderTaskList().CreateTask() );
- renderTask.SetViewport( viewport );
- renderTask.SetInputEnabled( true );
- renderTask.SetSourceActor( actor );
+ Viewport viewport(sceneSize.width * 0.5f, sceneSize.height * 0.5f, sceneSize.width * 0.5f, sceneSize.height * 0.5f);
+ RenderTask renderTask(application.GetScene().GetRenderTaskList().CreateTask());
+ renderTask.SetViewport(viewport);
+ renderTask.SetInputEnabled(true);
+ renderTask.SetSourceActor(actor);
// Render and notify
application.SendNotification();
application.Render();
// Connect to layer's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
- layer.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
+ layer.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Ensure renderTask actor can be hit too.
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Disable input on renderTask, should not be hittable
- renderTask.SetInputEnabled( false );
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( viewport.x + 5.0f, viewport.y + 5.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ renderTask.SetInputEnabled(false);
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(viewport.x + 5.0f, viewport.y + 5.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliTouchEventOffscreenRenderTasks(void)
{
- TestApplication application;
- Integration::Scene scene ( application.GetScene() );
- Vector2 sceneSize ( scene.GetSize() );
+ TestApplication application;
+ Integration::Scene scene(application.GetScene());
+ Vector2 sceneSize(scene.GetSize());
// FrameBufferImage for offscreen RenderTask
FrameBuffer frameBuffer = FrameBuffer::New(sceneSize.width, sceneSize.height);
// Create a renderable actor to display the FrameBufferImage
Actor renderableActor = CreateRenderableActor(frameBuffer.GetColorTexture());
- renderableActor.SetProperty( Actor::Property::PARENT_ORIGIN,ParentOrigin::CENTER);
- renderableActor.SetProperty( Actor::Property::SIZE, Vector2( sceneSize.x, sceneSize.y ) );
- renderableActor.ScaleBy( Vector3(1.0f, -1.0f, 1.0f) ); // FIXME
- scene.Add( renderableActor );
+ renderableActor.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER);
+ renderableActor.SetProperty(Actor::Property::SIZE, Vector2(sceneSize.x, sceneSize.y));
+ renderableActor.ScaleBy(Vector3(1.0f, -1.0f, 1.0f)); // FIXME
+ scene.Add(renderableActor);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- scene.Add( actor );
- application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE ); // Ensure framebuffer connects
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ scene.Add(actor);
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE); // Ensure framebuffer connects
- scene.GetRenderTaskList().GetTask( 0u ).SetScreenToFrameBufferFunction( RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION );
+ scene.GetRenderTaskList().GetTask(0u).SetScreenToFrameBufferFunction(RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION);
// Create a RenderTask
RenderTask renderTask = scene.GetRenderTaskList().CreateTask();
- renderTask.SetSourceActor( actor );
+ renderTask.SetSourceActor(actor);
renderTask.SetFrameBuffer(frameBuffer);
- renderTask.SetInputEnabled( true );
+ renderTask.SetInputEnabled(true);
// Create another RenderTask
- RenderTask renderTask2( scene.GetRenderTaskList().CreateTask() );
- renderTask2.SetInputEnabled( true );
+ RenderTask renderTask2(scene.GetRenderTaskList().CreateTask());
+ renderTask2.SetInputEnabled(true);
// Render and notify
application.SendNotification();
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
int UtcDaliTouchEventMultipleRenderableActors(void)
{
- TestApplication application;
- Integration::Scene scene ( application.GetScene() );
- Vector2 sceneSize ( scene.GetSize() );
+ TestApplication application;
+ Integration::Scene scene(application.GetScene());
+ Vector2 sceneSize(scene.GetSize());
Actor parent = CreateRenderableActor();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
scene.Add(parent);
Actor actor = CreateRenderableActor();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(actor);
// Render and notify
application.Render();
// Connect to layer's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- parent.TouchedSignal().Connect( &application, functor );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ parent.TouchedSignal().Connect(&application, functor);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.touchedActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.touchedActor);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- RemoveActorFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ RemoveActorFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Register for leave events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Re-add, render and notify
application.Render();
// Emit another signal outside of actor's area, should not get anything as the scene has changed.
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Render and notify
application.Render();
// Emit another signal outside of actor's area, should not get anything as the scene has changed.
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Re-add actor back to scene, render and notify
application.Render();
// Emit another down event
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Completely delete the actor
actor.Reset();
// Emit event, should not crash and should not receive an event.
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 210.0f, 210.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(210.0f, 210.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Remove actor from scene
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
data.Reset();
// Render and notify
application.Render();
// Emit a move at the same point, we should not be signalled.
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Add a layer to overlap the actor
Layer layer = Layer::New();
- layer.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- layer.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
- application.GetScene().Add( layer );
+ layer.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ layer.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ application.GetScene().Add(layer);
layer.RaiseToTop();
// Render and notify
application.Render();
// Emit a few touch signals
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Set layer to consume all touch
- layer.SetProperty( Layer::Property::CONSUMES_TOUCH, true );
+ layer.SetProperty(Layer::Property::CONSUMES_TOUCH, true);
// Render and notify
application.SendNotification();
application.Render();
// Emit the same signals again, should not receive
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::UP, Vector2( 10.0f, 10.0f ) ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ application.ProcessEvent(GenerateSingleTouch(PointState::UP, Vector2(10.0f, 10.0f)));
DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
int UtcDaliTouchEventLeaveActorReadded(void)
{
- TestApplication application;
+ TestApplication application;
Integration::Scene scene = application.GetScene();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
scene.Add(actor);
// Set actor to receive touch-events
- actor.SetProperty( Actor::Property::LEAVE_REQUIRED, true );
+ actor.SetProperty(Actor::Property::LEAVE_REQUIRED, true);
// Render and notify
application.SendNotification();
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down and motion
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 11.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(11.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Remove actor from scene and add again
- scene.Remove( actor );
- scene.Add( actor );
+ scene.Remove(actor);
+ scene.Add(actor);
// Emit a motion within the actor's bounds
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 12.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(12.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit a motion outside the actor's bounds
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 200.0f, 200.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(200.0f, 200.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::LEAVE, data.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
END_TEST;
int UtcDaliTouchEventClippedActor(void)
{
- TestApplication application;
+ TestApplication application;
Integration::Scene scene = application.GetScene();
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- scene.Add( actor );
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ scene.Add(actor);
Actor clippingActor = Actor::New();
- clippingActor.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
- clippingActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- clippingActor.SetProperty( Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN );
- scene.Add( clippingActor );
+ clippingActor.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
+ clippingActor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ clippingActor.SetProperty(Actor::Property::CLIPPING_MODE, ClippingMode::CLIP_CHILDREN);
+ scene.Add(clippingActor);
// Add a child to the clipped region.
Actor clippingChild = Actor::New();
- clippingChild.SetProperty( Actor::Property::SIZE, Vector2( 50.0f, 50.0f ) );
- clippingChild.SetProperty( Actor::Property::POSITION, Vector2( 25.0f, 25.0f ));
- clippingChild.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
- clippingActor.Add( clippingChild );
+ clippingChild.SetProperty(Actor::Property::SIZE, Vector2(50.0f, 50.0f));
+ clippingChild.SetProperty(Actor::Property::POSITION, Vector2(25.0f, 25.0f));
+ clippingChild.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
+ clippingActor.Add(clippingChild);
// Render and notify.
application.SendNotification();
application.Render();
// Connect to actor's touch signal.
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit an event within clipped area - no hit.
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Emit an event outside the clipped area but within the actor area, we should have a hit.
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 60.0f, 60.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(60.0f, 60.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
- clippingChild.TouchedSignal().Connect( &application, functor );
+ clippingChild.TouchedSignal().Connect(&application, functor);
// Emit an event inside part of the child which is within the clipped area, we should have a hit.
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 30.0f, 30.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(30.0f, 30.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
data.Reset();
// Render and notify
actor.Unparent();
// Should receive an interrupted event
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
data.Reset();
// Render and notify
parent.Unparent();
// Should receive an interrupted event
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false /* Do not consume */ );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false /* Do not consume */);
+ actor.TouchedSignal().Connect(&application, functor);
// Connect to parent's touched signal
- SignalData parentData;
- TouchEventFunctor parentFunctor( parentData );
- parent.TouchedSignal().Connect( &application, parentFunctor );
+ SignalData parentData;
+ TouchEventFunctor parentFunctor(parentData);
+ parent.TouchedSignal().Connect(&application, parentFunctor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == data.touchedActor );
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == parentData.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( parent == parentData.touchedActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == data.touchedActor);
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(parent == parentData.touchedActor);
data.Reset();
parentData.Reset();
actor.Unparent();
// Should receive an interrupted event for both actor & parent
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
parentData.Reset();
application.Render();
// Emit a motion signal
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
data.Reset();
parentData.Reset();
// Parent is now consumer, connect again to the touched signal of the actor so that it becomes the consumer
- SignalData secondData;
- TouchEventFunctor secondFunctor( secondData /* Consume */ );
- actor.TouchedSignal().Connect( &application, secondFunctor );
+ SignalData secondData;
+ TouchEventFunctor secondFunctor(secondData /* Consume */);
+ actor.TouchedSignal().Connect(&application, secondFunctor);
// Unparent the actor
actor.Unparent();
// Should receive an interrupted event for both actor functors & the parent as well as it was last consumer
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( true, secondData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, secondData.receivedTouch.points[0].state, TEST_LOCATION );
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, secondData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, secondData.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
parentData.Reset();
secondData.Reset();
int UtcDaliTouchEventInterruptedDifferentConsumer(void)
{
TestApplication application;
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
Actor parent = Actor::New();
- parent.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- parent.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ parent.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ parent.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(parent);
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
parent.Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data, false /* Do not consume */ );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data, false /* Do not consume */);
+ actor.TouchedSignal().Connect(&application, functor);
// Connect to parent's touched signal
- SignalData parentData;
- TouchEventFunctor parentFunctor( parentData, false /* Do not consume */ );
- parent.TouchedSignal().Connect( &application, parentFunctor );
+ SignalData parentData;
+ TouchEventFunctor parentFunctor(parentData, false /* Do not consume */);
+ parent.TouchedSignal().Connect(&application, parentFunctor);
// Connect to root's touched signal and consume
- SignalData rootData;
- TouchEventFunctor rootFunctor( rootData );
- rootActor.TouchedSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ TouchEventFunctor rootFunctor(rootData);
+ rootActor.TouchedSignal().Connect(&application, rootFunctor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( actor == data.touchedActor );
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == parentData.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( parent == parentData.touchedActor );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_CHECK( actor == rootData.receivedTouch.points[0].hitActor );
- DALI_TEST_CHECK( rootActor == rootData.touchedActor );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(actor == data.touchedActor);
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, parentData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == parentData.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(parent == parentData.touchedActor);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, rootData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == rootData.receivedTouch.points[0].hitActor);
+ DALI_TEST_CHECK(rootActor == rootData.touchedActor);
data.Reset();
parentData.Reset();
rootData.Reset();
// Root is now consumer, connect to the touched signal of the parent so that it becomes the consumer
- SignalData secondData;
- TouchEventFunctor secondFunctor( secondData /* Consume */ );
- parent.TouchedSignal().Connect( &application, secondFunctor );
+ SignalData secondData;
+ TouchEventFunctor secondFunctor(secondData /* Consume */);
+ parent.TouchedSignal().Connect(&application, secondFunctor);
// Emit an interrupted signal, all three should STILL be called
- application.ProcessEvent( GenerateSingleTouch( PointState::INTERRUPTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( true, parentData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::INTERRUPTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, parentData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, parentData.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::INTERRUPTED, rootData.receivedTouch.points[0].state, TEST_LOCATION);
data.Reset();
parentData.Reset();
rootData.Reset();
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with an angle
- Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
- touchEvent.points[ 0 ].SetRadius( 100.0f );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION );
+ Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
+ touchEvent.points[0].SetRadius(100.0f);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION);
+ DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with an angle
- Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
- touchEvent.points[ 0 ].SetRadius( 100.0f, Vector2( 20.0f, 10.0f ) );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( 100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION );
- DALI_TEST_EQUALS( 20.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION );
- DALI_TEST_EQUALS( 10.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION );
+ Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
+ touchEvent.points[0].SetRadius(100.0f, Vector2(20.0f, 10.0f));
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(100.0f, data.receivedTouch.points[0].radius, TEST_LOCATION);
+ DALI_TEST_EQUALS(20.0f, data.receivedTouch.points[0].ellipseRadius.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(10.0f, data.receivedTouch.points[0].ellipseRadius.y, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with an angle
- Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
- touchEvent.points[ 0 ].SetAngle( Degree( 90.0f ) );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( Degree( 90.0f ), data.receivedTouch.points[0].angle, TEST_LOCATION );
+ Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
+ touchEvent.points[0].SetAngle(Degree(90.0f));
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(Degree(90.0f), data.receivedTouch.points[0].angle, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with an angle
- Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
- touchEvent.points[ 0 ].SetPressure( 10.0f );
- application.ProcessEvent( touchEvent );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION );
- DALI_TEST_EQUALS( 10.0f, data.receivedTouch.points[0].pressure, TEST_LOCATION );
+ Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
+ touchEvent.points[0].SetPressure(10.0f);
+ application.ProcessEvent(touchEvent);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(PointState::DOWN, data.receivedTouch.points[0].state, TEST_LOCATION);
+ DALI_TEST_EQUALS(10.0f, data.receivedTouch.points[0].pressure, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
-
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with an angle
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
-
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- HandleData handleData;
- TouchEventHandleFunctor functor( handleData );
- actor.TouchedSignal().Connect( &application, functor );
+ HandleData handleData;
+ TouchEventHandleFunctor functor(handleData);
+ actor.TouchedSignal().Connect(&application, functor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Vector2 localCoordinates;
- actor.ScreenToLocal( localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y );
+ actor.ScreenToLocal(localCoordinates.x, localCoordinates.y, screenCoordinates.x, screenCoordinates.y);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::DOWN, screenCoordinates ) );
+ application.ProcessEvent(GenerateSingleTouch(PointState::DOWN, screenCoordinates));
TouchEvent data = handleData.receivedTouchHandle;
- DALI_TEST_EQUALS( data.GetDeviceClass( -1 ), Device::Class::NONE, TEST_LOCATION );
- DALI_TEST_EQUALS( data.GetDeviceSubclass( -1 ), Device::Subclass::NONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(data.GetDeviceClass(-1), Device::Class::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.GetDeviceSubclass(-1), Device::Subclass::NONE, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- HandleData handleData;
- TouchEventHandleFunctor functor( handleData );
- actor.TouchedSignal().Connect( &application, functor );
+ HandleData handleData;
+ TouchEventHandleFunctor functor(handleData);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with MouseButton
- Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
- touchEvent.points[ 0 ].SetMouseButton( static_cast< MouseButton::Type >( 3 ) );
- application.ProcessEvent( touchEvent );
+ Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
+ touchEvent.points[0].SetMouseButton(static_cast<MouseButton::Type>(3));
+ application.ProcessEvent(touchEvent);
TouchEvent data = handleData.receivedTouchHandle;
- DALI_TEST_EQUALS( data.GetMouseButton( 0 ), MouseButton::SECONDARY, TEST_LOCATION );
+ DALI_TEST_EQUALS(data.GetMouseButton(0), MouseButton::SECONDARY, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- HandleData handleData;
- TouchEventHandleFunctor functor( handleData );
- actor.TouchedSignal().Connect( &application, functor );
+ HandleData handleData;
+ TouchEventHandleFunctor functor(handleData);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal with MouseButton
- Integration::TouchEvent touchEvent = GenerateSingleTouch( PointState::DOWN, Vector2( 10.0f, 10.0f ) );
- touchEvent.points[ 0 ].SetMouseButton( static_cast< MouseButton::Type >( 2 ) );
- application.ProcessEvent( touchEvent );
+ Integration::TouchEvent touchEvent = GenerateSingleTouch(PointState::DOWN, Vector2(10.0f, 10.0f));
+ touchEvent.points[0].SetMouseButton(static_cast<MouseButton::Type>(2));
+ application.ProcessEvent(touchEvent);
TouchEvent data = handleData.receivedTouchHandle;
- DALI_TEST_EQUALS( data.GetMouseButton( 0 ), MouseButton::TERTIARY, TEST_LOCATION );
- DALI_TEST_EQUALS( data.GetMouseButton( 3 ), MouseButton::INVALID, TEST_LOCATION );
+ DALI_TEST_EQUALS(data.GetMouseButton(0), MouseButton::TERTIARY, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.GetMouseButton(3), MouseButton::INVALID, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's touched signal
- SignalData data;
- TouchEventFunctor functor( data );
- actor.TouchedSignal().Connect( &application, functor );
+ SignalData data;
+ TouchEventFunctor functor(data);
+ actor.TouchedSignal().Connect(&application, functor);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Now motion outside of actor, we should not receive the event
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 110.0f, 110.0f ) ) );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f)));
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
// Up event, should receive an interrupted
- application.ProcessEvent( GenerateSingleTouch( PointState::FINISHED, Vector2( 110.0f, 110.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::INTERRUPTED, TEST_LOCATION);
// Now set the capture property
- actor.SetProperty( DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
+ actor.SetProperty(DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START, true);
// Emit a down signal
- application.ProcessEvent( GenerateSingleTouch( PointState::STARTED, Vector2( 10.0f, 10.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::STARTED, Vector2(10.0f, 10.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Now motion outside of actor, we now SHOULD receive the event
- application.ProcessEvent( GenerateSingleTouch( PointState::MOTION, Vector2( 110.0f, 110.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::MOTION, Vector2(110.0f, 110.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
data.Reset();
// Up event, we should receive it again, but as ended rather than interrupted
- application.ProcessEvent( GenerateSingleTouch( PointState::FINISHED, Vector2( 110.0f, 110.0f ) ) );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( data.receivedTouch.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION );
+ application.ProcessEvent(GenerateSingleTouch(PointState::FINISHED, Vector2(110.0f, 110.0f)));
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(data.receivedTouch.GetPoint(0).state, PointState::FINISHED, TEST_LOCATION);
END_TEST;
}
int UtcDaliTouchEventIntegNewTouchEvent(void)
{
- uint32_t timestamp = 92858u;
- TouchPoint tp(1, PointState::STARTED, 34.4f, 123.89f, 5.0f, 7.0f);
+ uint32_t timestamp = 92858u;
+ TouchPoint tp(1, PointState::STARTED, 34.4f, 123.89f, 5.0f, 7.0f);
Dali::TouchEvent touchEvent = Integration::NewTouchEvent(timestamp, tp);
DALI_TEST_EQUALS(touchEvent.GetPointCount(), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS(touchEvent.GetState(0), PointState::STARTED, TEST_LOCATION );
- DALI_TEST_EQUALS(touchEvent.GetLocalPosition(0), Vector2(5.0f, 7.0f), TEST_LOCATION );
- DALI_TEST_EQUALS(touchEvent.GetScreenPosition(0), Vector2(34.4f, 123.89f), TEST_LOCATION );
-
+ DALI_TEST_EQUALS(touchEvent.GetState(0), PointState::STARTED, TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetLocalPosition(0), Vector2(5.0f, 7.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(touchEvent.GetScreenPosition(0), Vector2(34.4f, 123.89f), TEST_LOCATION);
END_TEST;
}
*
*/
-#include <iostream>
-#include <stdlib.h>
-#include <limits>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
-#include <dali/internal/event/common/type-info-impl.h>
-#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/hover-event-integ.h>
+#include <dali/integration-api/events/touch-event-integ.h>
+#include <dali/internal/event/common/type-info-impl.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
-using namespace Dali;
+#include <iostream>
+#include <limits>
+using namespace Dali;
namespace
{
-
// Stores data that is populated in the callback and will be read by the Test cases
struct SignalData
{
SignalData()
- : functorCalled( false ),
- voidFunctorCalled( false ),
- receivedGesture( ),
+ : functorCalled(false),
+ voidFunctorCalled(false),
+ receivedGesture(),
pressedActor()
- {}
+ {
+ }
void Reset()
{
- functorCalled = false;
+ functorCalled = false;
voidFunctorCalled = false;
receivedGesture.Reset();
pressedActor.Reset();
}
- bool functorCalled;
- bool voidFunctorCalled;
+ bool functorCalled;
+ bool voidFunctorCalled;
LongPressGesture receivedGesture;
- Actor pressedActor;
+ Actor pressedActor;
};
// Functor that sets the data when called
struct GestureReceivedFunctor
{
- GestureReceivedFunctor(SignalData& data) : signalData(data) { }
+ GestureReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
void operator()(Actor actor, LongPressGesture longPress)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedGesture = longPress;
- signalData.pressedActor = actor;
+ signalData.pressedActor = actor;
}
void operator()()
// Create function as Init function called
//
static bool CreateCustomInitCalled = false;
-BaseHandle CreateCustomInit(void)
+BaseHandle CreateCustomInit(void)
{
CreateCustomInitCalled = true;
return BaseHandle();
}
static bool CreateCustomNamedInitCalled = false;
-BaseHandle CreateCustomNamedInit(void)
+BaseHandle CreateCustomNamedInit(void)
{
CreateCustomNamedInitCalled = true;
return BaseHandle();
}
-const std::string scriptedName("PopupStyle");
-static TypeRegistration scriptedType( scriptedName, typeid(Dali::CustomActor), CreateCustomNamedInit );
+const std::string scriptedName("PopupStyle");
+static TypeRegistration scriptedType(scriptedName, typeid(Dali::CustomActor), CreateCustomNamedInit);
// Property Registration
bool setPropertyCalled = false;
bool getPropertyCalled = false;
-void SetProperty( BaseObject* object, Property::Index propertyIndex, const Property::Value& value )
+void SetProperty(BaseObject* object, Property::Index propertyIndex, const Property::Value& value)
{
setPropertyCalled = true;
}
-Property::Value GetProperty( BaseObject* object, Property::Index propertyIndex )
+Property::Value GetProperty(BaseObject* object, Property::Index propertyIndex)
{
getPropertyCalled = true;
- return Property::Value( true );
+ return Property::Value(true);
}
-
-
/*******************************************************************************
*
* Custom Actor
{
struct MyTestCustomActor : public CustomActorImpl
{
- typedef Signal< void ()> SignalType;
- typedef Signal< void (float)> SignalTypeFloat;
+ typedef Signal<void()> SignalType;
+ typedef Signal<void(float)> SignalTypeFloat;
- MyTestCustomActor() : CustomActorImpl( ActorFlags() )
- { }
+ MyTestCustomActor()
+ : CustomActorImpl(ActorFlags())
+ {
+ }
virtual ~MyTestCustomActor()
- { }
+ {
+ }
void ResetCallStack()
{
}
// From CustomActorImpl
- virtual void OnSceneConnection( int depth )
+ virtual void OnSceneConnection(int depth)
{
}
virtual void OnSceneDisconnection()
}
virtual Vector3 GetNaturalSize()
{
- return Vector3( 0.0f, 0.0f, 0.0f );
+ return Vector3(0.0f, 0.0f, 0.0f);
}
- virtual float GetHeightForWidth( float width )
+ virtual float GetHeightForWidth(float width)
{
return 0.0f;
}
- virtual float GetWidthForHeight( float height )
+ virtual float GetWidthForHeight(float height)
{
return 0.0f;
}
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
+ virtual void OnRelayout(const Vector2& size, RelayoutContainer& container)
{
}
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+ virtual void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
{
}
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
+ virtual void OnCalculateRelayoutSize(Dimension::Type dimension)
{
}
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+ virtual float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension)
{
return 0.0f;
}
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
+ virtual void OnLayoutNegotiated(float size, Dimension::Type dimension)
{
}
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
+ virtual bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS)
{
return false;
}
public:
-
SignalType mSignal;
};
class MyTestCustomActor : public CustomActor
{
public:
-
- typedef Signal< void ()> SignalType;
- typedef Signal< void (float)> SignalTypeFloat;
+ typedef Signal<void()> SignalType;
+ typedef Signal<void(float)> SignalTypeFloat;
MyTestCustomActor()
{
static MyTestCustomActor New()
{
Impl::MyTestCustomActor* p = new Impl::MyTestCustomActor;
- return MyTestCustomActor( *p ); // takes ownership
+ return MyTestCustomActor(*p); // takes ownership
}
virtual ~MyTestCustomActor()
{
}
- static MyTestCustomActor DownCast( BaseHandle handle )
+ static MyTestCustomActor DownCast(BaseHandle handle)
{
MyTestCustomActor result;
- CustomActor custom = Dali::CustomActor::DownCast( handle );
- if ( custom )
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
+ if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
- if (impl)
+ if(impl)
{
result = MyTestCustomActor(customImpl.GetOwner());
}
SignalType& GetCustomSignal()
{
Dali::RefObject& obj = GetImplementation();
- return static_cast<Impl::MyTestCustomActor&>( obj ).mSignal;
+ return static_cast<Impl::MyTestCustomActor&>(obj).mSignal;
}
private:
-
MyTestCustomActor(Internal::CustomActor* internal)
: CustomActor(internal)
{
}
- MyTestCustomActor( Impl::MyTestCustomActor& impl )
- : CustomActor( impl )
+ MyTestCustomActor(Impl::MyTestCustomActor& impl)
+ : CustomActor(impl)
{
}
};
-
class MyTestCustomActor2 : public CustomActor
{
public:
-
struct Property
{
enum
{
- P1=Dali::PROPERTY_REGISTRATION_START_INDEX,
+ P1 = Dali::PROPERTY_REGISTRATION_START_INDEX,
P2
};
};
-
MyTestCustomActor2()
{
}
{
}
- static MyTestCustomActor2 DownCast( BaseHandle handle )
+ static MyTestCustomActor2 DownCast(BaseHandle handle)
{
MyTestCustomActor2 result;
- CustomActor custom = Dali::CustomActor::DownCast( handle );
- if ( custom )
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
+ if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
- if (impl)
+ if(impl)
{
result = MyTestCustomActor2(customImpl.GetOwner());
}
}
private:
-
MyTestCustomActor2(Internal::CustomActor* internal)
: CustomActor(internal)
{
}
- MyTestCustomActor2( Impl::MyTestCustomActor& impl )
- : CustomActor( impl )
+ MyTestCustomActor2(Impl::MyTestCustomActor& impl)
+ : CustomActor(impl)
{
}
};
-static TypeRegistration customTypeInit( typeid(MyTestCustomActor2), typeid(Dali::CustomActor), CreateCustomInit, true );
-
-PropertyRegistration P1( customTypeInit, "propertyOne", MyTestCustomActor2::Property::P1, Property::INTEGER, &SetProperty, &GetProperty );
-PropertyRegistration P2( customTypeInit, "propertyTwo", MyTestCustomActor2::Property::P2, Property::STRING, &SetProperty, &GetProperty );
+static TypeRegistration customTypeInit(typeid(MyTestCustomActor2), typeid(Dali::CustomActor), CreateCustomInit, true);
+PropertyRegistration P1(customTypeInit, "propertyOne", MyTestCustomActor2::Property::P1, Property::INTEGER, &SetProperty, &GetProperty);
+PropertyRegistration P2(customTypeInit, "propertyTwo", MyTestCustomActor2::Property::P2, Property::STRING, &SetProperty, &GetProperty);
class MyTestCustomActor3 : public CustomActor
{
{
}
- static MyTestCustomActor3 DownCast( BaseHandle handle )
+ static MyTestCustomActor3 DownCast(BaseHandle handle)
{
MyTestCustomActor3 result;
- CustomActor custom = Dali::CustomActor::DownCast( handle );
- if ( custom )
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
+ if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
- if (impl)
+ if(impl)
{
result = MyTestCustomActor3(customImpl.GetOwner());
}
}
private:
-
MyTestCustomActor3(Internal::CustomActor* internal)
: CustomActor(internal)
{
}
- MyTestCustomActor3( Impl::MyTestCustomActor& impl )
- : CustomActor( impl )
+ MyTestCustomActor3(Impl::MyTestCustomActor& impl)
+ : CustomActor(impl)
{
}
};
-static TypeRegistration customTypeBadInit( typeid(MyTestCustomActor3), typeid(Dali::CustomActor), NULL, false );
+static TypeRegistration customTypeBadInit(typeid(MyTestCustomActor3), typeid(Dali::CustomActor), NULL, false);
BaseHandle CreateCustom(void)
{
static std::string lastSignalConnectionCustom;
-bool DoConnectSignalCustom( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+bool DoConnectSignalCustom(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
{
lastSignalConnectionCustom = signalName;
- bool connected( true );
+ bool connected(true);
- Dali::BaseHandle handle(object);
+ Dali::BaseHandle handle(object);
MyTestCustomActor customActor = MyTestCustomActor::DownCast(handle);
- if( "sig1" == signalName )
+ if("sig1" == signalName)
{
- customActor.GetCustomSignal().Connect( tracker, functor );
+ customActor.GetCustomSignal().Connect(tracker, functor);
}
else
{
return connected;
}
-bool DoConnectSignalCustomFailure( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
+bool DoConnectSignalCustomFailure(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor)
{
lastSignalConnectionCustom = "failed";
++mCurrentInstanceCount;
}
- CustomTestFunctor( const CustomTestFunctor& copyMe )
+ CustomTestFunctor(const CustomTestFunctor& copyMe)
{
++mTotalInstanceCount;
++mCurrentInstanceCount;
static int mCallbackCount;
};
-int CustomTestFunctor::mTotalInstanceCount = 0;
+int CustomTestFunctor::mTotalInstanceCount = 0;
int CustomTestFunctor::mCurrentInstanceCount = 0;
-int CustomTestFunctor::mCallbackCount = 0;
+int CustomTestFunctor::mCallbackCount = 0;
static void ResetFunctorCounts()
{
}
static std::string lastActionCustom;
-bool DoActionCustom(BaseObject* object, const std::string& actionName, const Property::Map& /*attributes*/)
+bool DoActionCustom(BaseObject* object, const std::string& actionName, const Property::Map& /*attributes*/)
{
lastActionCustom = actionName;
return true;
}
// Custom type registration
-static TypeRegistration customType1( typeid(MyTestCustomActor), typeid(Dali::CustomActor), CreateCustom );
+static TypeRegistration customType1(typeid(MyTestCustomActor), typeid(Dali::CustomActor), CreateCustom);
// Custom signals
-static SignalConnectorType customSignalConnector1( customType1, "sig1", DoConnectSignalCustom );
-static SignalConnectorType customSignalConnector2( customType1, "sig2", DoConnectSignalCustomFailure );
-static const int TEST_SIGNAL_COUNT = 2;
+static SignalConnectorType customSignalConnector1(customType1, "sig1", DoConnectSignalCustom);
+static SignalConnectorType customSignalConnector2(customType1, "sig2", DoConnectSignalCustomFailure);
+static const int TEST_SIGNAL_COUNT = 2;
// Custom actions
-static TypeAction customAction1( customType1, "act1", DoActionCustom);
-static const int TEST_ACTION_COUNT = 1;
+static TypeAction customAction1(customType1, "act1", DoActionCustom);
+static const int TEST_ACTION_COUNT = 1;
class TestConnectionTracker : public ConnectionTracker
{
public:
-
TestConnectionTracker()
{
}
BaseHandle CreateNamedActorType()
{
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::NAME, "NamedActor" );
+ actor.SetProperty(Actor::Property::NAME, "NamedActor");
return actor;
}
-TypeRegistration namedActorType( "MyNamedActor", typeid(Dali::Actor), CreateNamedActorType );
-PropertyRegistration namedActorPropertyOne( namedActorType, "propName", PROPERTY_REGISTRATION_START_INDEX, Property::BOOLEAN, &SetProperty, &GetProperty );
+TypeRegistration namedActorType("MyNamedActor", typeid(Dali::Actor), CreateNamedActorType);
+PropertyRegistration namedActorPropertyOne(namedActorType, "propName", PROPERTY_REGISTRATION_START_INDEX, Property::BOOLEAN, &SetProperty, &GetProperty);
} // Anonymous namespace
TestApplication application;
TypeRegistry registry = TypeRegistry::Get();
- DALI_TEST_CHECK( registry );
+ DALI_TEST_CHECK(registry);
END_TEST;
}
TestApplication application;
TypeRegistry registry;
- DALI_TEST_CHECK( !registry );
+ DALI_TEST_CHECK(!registry);
END_TEST;
}
TestApplication application;
TypeRegistry registry = TypeRegistry::Get();
- DALI_TEST_CHECK( registry );
+ DALI_TEST_CHECK(registry);
- TypeRegistry copy( registry );
- DALI_TEST_CHECK( copy );
+ TypeRegistry copy(registry);
+ DALI_TEST_CHECK(copy);
- DALI_TEST_CHECK( registry.GetTypeInfo( "Actor" ).GetName() == copy.GetTypeInfo( "Actor" ).GetName() );
+ DALI_TEST_CHECK(registry.GetTypeInfo("Actor").GetName() == copy.GetTypeInfo("Actor").GetName());
END_TEST;
}
TestApplication application;
TypeRegistry registry = TypeRegistry::Get();
- DALI_TEST_CHECK( registry );
+ DALI_TEST_CHECK(registry);
TypeRegistry copy = registry;
- DALI_TEST_CHECK( copy );
- DALI_TEST_CHECK( registry == copy );
+ DALI_TEST_CHECK(copy);
+ DALI_TEST_CHECK(registry == copy);
- DALI_TEST_CHECK( registry.GetTypeInfo( "Actor" ).GetName() == copy.GetTypeInfo( "Actor" ).GetName() );
+ DALI_TEST_CHECK(registry.GetTypeInfo("Actor").GetName() == copy.GetTypeInfo("Actor").GetName());
END_TEST;
}
TestApplication application;
TypeRegistry registry = TypeRegistry::Get();
- DALI_TEST_CHECK( registry );
- DALI_TEST_EQUALS( 16, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( registry.GetTypeInfo( "Actor" ).GetName() == "Actor" );
+ DALI_TEST_CHECK(registry);
+ DALI_TEST_EQUALS(16, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(registry.GetTypeInfo("Actor").GetName() == "Actor");
- TypeRegistry movedRegistry = std::move( registry );
- DALI_TEST_CHECK( movedRegistry );
- DALI_TEST_EQUALS( 16, movedRegistry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( movedRegistry.GetTypeInfo( "Actor" ).GetName() == "Actor" );
- DALI_TEST_CHECK( !registry );
+ TypeRegistry movedRegistry = std::move(registry);
+ DALI_TEST_CHECK(movedRegistry);
+ DALI_TEST_EQUALS(16, movedRegistry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(movedRegistry.GetTypeInfo("Actor").GetName() == "Actor");
+ DALI_TEST_CHECK(!registry);
- Dali::TypeInfo info = movedRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( info );
- DALI_TEST_EQUALS( 2, info.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( info.GetName() == "Actor" );
+ Dali::TypeInfo info = movedRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(info);
+ DALI_TEST_EQUALS(2, info.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(info.GetName() == "Actor");
- Dali::TypeInfo movedInfo = std::move( info );
- DALI_TEST_CHECK( movedInfo );
- DALI_TEST_EQUALS( 2, movedInfo.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( movedInfo.GetName() == "Actor" );
- DALI_TEST_CHECK( !info );
+ Dali::TypeInfo movedInfo = std::move(info);
+ DALI_TEST_CHECK(movedInfo);
+ DALI_TEST_EQUALS(2, movedInfo.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(movedInfo.GetName() == "Actor");
+ DALI_TEST_CHECK(!info);
END_TEST;
}
TestApplication application;
TypeRegistry registry = TypeRegistry::Get();
- DALI_TEST_CHECK( registry );
- DALI_TEST_EQUALS( 16, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( registry.GetTypeInfo( "Actor" ).GetName() == "Actor" );
+ DALI_TEST_CHECK(registry);
+ DALI_TEST_EQUALS(16, registry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(registry.GetTypeInfo("Actor").GetName() == "Actor");
TypeRegistry movedRegistry;
- movedRegistry = std::move( registry );
- DALI_TEST_CHECK( movedRegistry );
- DALI_TEST_EQUALS( 16, movedRegistry.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( movedRegistry.GetTypeInfo( "Actor" ).GetName() == "Actor" );
- DALI_TEST_CHECK( !registry );
+ movedRegistry = std::move(registry);
+ DALI_TEST_CHECK(movedRegistry);
+ DALI_TEST_EQUALS(16, movedRegistry.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(movedRegistry.GetTypeInfo("Actor").GetName() == "Actor");
+ DALI_TEST_CHECK(!registry);
- Dali::TypeInfo info = movedRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( info );
- DALI_TEST_EQUALS( 2, info.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( info.GetName() == "Actor" );
+ Dali::TypeInfo info = movedRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(info);
+ DALI_TEST_EQUALS(2, info.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(info.GetName() == "Actor");
Dali::TypeInfo movedInfo;
- movedInfo = std::move( info );
- DALI_TEST_CHECK( movedInfo );
- DALI_TEST_EQUALS( 2, movedInfo.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_CHECK( movedInfo.GetName() == "Actor" );
- DALI_TEST_CHECK( !info );
+ movedInfo = std::move(info);
+ DALI_TEST_CHECK(movedInfo);
+ DALI_TEST_EQUALS(2, movedInfo.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_CHECK(movedInfo.GetName() == "Actor");
+ DALI_TEST_CHECK(!info);
END_TEST;
}
TypeRegistry registry = TypeRegistry::Get();
TypeRegistry registry2;
registry2 = registry;
- DALI_TEST_CHECK( registry2 );
+ DALI_TEST_CHECK(registry2);
- DALI_TEST_CHECK( registry2.GetTypeInfo( "Actor" ).GetName() == registry2.GetTypeInfo( "Actor" ).GetName() );
+ DALI_TEST_CHECK(registry2.GetTypeInfo("Actor").GetName() == registry2.GetTypeInfo("Actor").GetName());
END_TEST;
}
TypeInfo type;
// camera actor
- type = registry.GetTypeInfo( "CameraActor" );
- DALI_TEST_CHECK( type );
+ type = registry.GetTypeInfo("CameraActor");
+ DALI_TEST_CHECK(type);
CameraActor ca = CameraActor::DownCast(type.CreateInstance());
- DALI_TEST_CHECK( ca );
- application.GetScene().Add( ca );
+ DALI_TEST_CHECK(ca);
+ application.GetScene().Add(ca);
application.Render();
// animations
- type = registry.GetTypeInfo( "Animation" );
- DALI_TEST_CHECK( type );
+ type = registry.GetTypeInfo("Animation");
+ DALI_TEST_CHECK(type);
Animation an = Animation::DownCast(type.CreateInstance());
- DALI_TEST_CHECK( an );
+ DALI_TEST_CHECK(an);
an.Play();
application.Render();
TypeInfo type;
- type = registry.GetTypeInfo( "MyDummyActor" );
- DALI_TEST_CHECK( !type );
+ type = registry.GetTypeInfo("MyDummyActor");
+ DALI_TEST_CHECK(!type);
END_TEST;
}
int UtcDaliTypeRegistryGetTypeInfoFromTypeIdP(void)
{
- TypeInfo named_type = TypeRegistry::Get().GetTypeInfo( "CameraActor" );
- TypeInfo typeinfo_type = TypeRegistry::Get().GetTypeInfo( typeid(Dali::CameraActor) );
+ TypeInfo named_type = TypeRegistry::Get().GetTypeInfo("CameraActor");
+ TypeInfo typeinfo_type = TypeRegistry::Get().GetTypeInfo(typeid(Dali::CameraActor));
- DALI_TEST_CHECK( named_type );
- DALI_TEST_CHECK( typeinfo_type );
+ DALI_TEST_CHECK(named_type);
+ DALI_TEST_CHECK(typeinfo_type);
// Check named and typeid are equivalent
- DALI_TEST_CHECK( named_type == typeinfo_type );
+ DALI_TEST_CHECK(named_type == typeinfo_type);
- DALI_TEST_CHECK( named_type.GetName() == typeinfo_type.GetName() );
- DALI_TEST_CHECK( named_type.GetBaseName() == typeinfo_type.GetBaseName() );
+ DALI_TEST_CHECK(named_type.GetName() == typeinfo_type.GetName());
+ DALI_TEST_CHECK(named_type.GetBaseName() == typeinfo_type.GetBaseName());
END_TEST;
}
int UtcDaliTypeRegistryGetTypeInfoFromTypeIdN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(Vector2) );
- DALI_TEST_CHECK( !typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(Vector2));
+ DALI_TEST_CHECK(!typeInfo);
END_TEST;
}
int UtcDaliTypeRegistryGetTypeNameCountP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo type;
+ TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeInfo type;
for(size_t i = 0; i < typeRegistry.GetTypeNameCount(); i++)
{
- type = typeRegistry.GetTypeInfo( typeRegistry.GetTypeName(i) );
- DALI_TEST_CHECK( type );
+ type = typeRegistry.GetTypeInfo(typeRegistry.GetTypeName(i));
+ DALI_TEST_CHECK(type);
}
END_TEST;
}
-
int UtcDaliTypeRegistryGetTypeNamesP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo type;
+ TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeInfo type;
for(size_t i = 0; i < typeRegistry.GetTypeNameCount(); i++)
{
- type = typeRegistry.GetTypeInfo( typeRegistry.GetTypeName(i) );
- DALI_TEST_CHECK( type );
+ type = typeRegistry.GetTypeInfo(typeRegistry.GetTypeName(i));
+ DALI_TEST_CHECK(type);
}
END_TEST;
}
-
// Note: No negative test case for UtcDaliTypeRegistryTypeRegistration can be implemented.
int UtcDaliTypeRegistryTypeRegistrationNotCallingCreateOnInitP(void)
{
TestApplication application;
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
- DALI_TEST_CHECK( type );
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyTestCustomActor");
+ DALI_TEST_CHECK(type);
- TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( "CustomActor" );
- DALI_TEST_CHECK( baseType );
+ TypeInfo baseType = TypeRegistry::Get().GetTypeInfo("CustomActor");
+ DALI_TEST_CHECK(baseType);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
- MyTestCustomActor customHandle = MyTestCustomActor::DownCast( handle );
- DALI_TEST_CHECK( customHandle );
+ MyTestCustomActor customHandle = MyTestCustomActor::DownCast(handle);
+ DALI_TEST_CHECK(customHandle);
- DALI_TEST_EQUALS( type.GetActionCount(), TEST_ACTION_COUNT + baseType.GetActionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(type.GetActionCount(), TEST_ACTION_COUNT + baseType.GetActionCount(), TEST_LOCATION);
- DALI_TEST_EQUALS( type.GetSignalCount(), TEST_SIGNAL_COUNT + baseType.GetSignalCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(type.GetSignalCount(), TEST_SIGNAL_COUNT + baseType.GetSignalCount(), TEST_LOCATION);
{
TestConnectionTracker tracker;
- bool connected = handle.ConnectSignal( &tracker, "sig1", CustomTestFunctor() );
- DALI_TEST_EQUALS( connected, true, TEST_LOCATION );
- DALI_TEST_CHECK( lastSignalConnectionCustom == "sig1" );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
+ bool connected = handle.ConnectSignal(&tracker, "sig1", CustomTestFunctor());
+ DALI_TEST_EQUALS(connected, true, TEST_LOCATION);
+ DALI_TEST_CHECK(lastSignalConnectionCustom == "sig1");
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION);
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION);
customHandle.GetCustomSignal().Emit();
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION);
}
// tracker should automatically disconnect here
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION);
// Test that functor is disconnected
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION);
customHandle.GetCustomSignal().Emit();
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1/*not incremented*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 1 /*not incremented*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION);
Property::Map attributes;
handle.DoAction("act1", attributes);
- DALI_TEST_CHECK( lastActionCustom == "act1" );
+ DALI_TEST_CHECK(lastActionCustom == "act1");
END_TEST;
}
{
TestApplication application;
- DALI_TEST_CHECK( "MyTestCustomActor2" == customTypeInit.RegisteredName() );
+ DALI_TEST_CHECK("MyTestCustomActor2" == customTypeInit.RegisteredName());
- DALI_TEST_CHECK( true == CreateCustomInitCalled );
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor2" );
- DALI_TEST_CHECK( type );
+ DALI_TEST_CHECK(true == CreateCustomInitCalled);
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyTestCustomActor2");
+ DALI_TEST_CHECK(type);
END_TEST;
}
TestApplication application;
// Create Named Actor Type
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyNamedActor" );
- DALI_TEST_CHECK( type );
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyNamedActor");
+ DALI_TEST_CHECK(type);
BaseHandle namedHandle = type.CreateInstance();
- DALI_TEST_CHECK( namedHandle );
- Actor namedActor( Actor::DownCast( namedHandle ) );
- DALI_TEST_CHECK( namedActor );
+ DALI_TEST_CHECK(namedHandle);
+ Actor namedActor(Actor::DownCast(namedHandle));
+ DALI_TEST_CHECK(namedActor);
- DALI_TEST_CHECK( namedActor.GetProperty< std::string >( Actor::Property::NAME ) == "NamedActor" );
- DALI_TEST_CHECK( type.GetName() == "MyNamedActor" );
- DALI_TEST_CHECK( type.GetBaseName() == "Actor" );
+ DALI_TEST_CHECK(namedActor.GetProperty<std::string>(Actor::Property::NAME) == "NamedActor");
+ DALI_TEST_CHECK(type.GetName() == "MyNamedActor");
+ DALI_TEST_CHECK(type.GetBaseName() == "Actor");
END_TEST;
}
{
TestApplication application;
- DALI_TEST_CHECK( scriptedName == scriptedType.RegisteredName() );
+ DALI_TEST_CHECK(scriptedName == scriptedType.RegisteredName());
- TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( scriptedName );
- DALI_TEST_CHECK( baseType );
+ TypeInfo baseType = TypeRegistry::Get().GetTypeInfo(scriptedName);
+ DALI_TEST_CHECK(baseType);
BaseHandle handle = baseType.CreateInstance();
- DALI_TEST_CHECK( true == CreateCustomNamedInitCalled );
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( scriptedName );
- DALI_TEST_CHECK( type );
+ DALI_TEST_CHECK(true == CreateCustomNamedInitCalled);
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo(scriptedName);
+ DALI_TEST_CHECK(type);
END_TEST;
}
-
int UtcDaliTypeRegistryRegisteredNameN(void)
{
TestApplication application;
- DALI_TEST_CHECK( scriptedName == scriptedType.RegisteredName() );
+ DALI_TEST_CHECK(scriptedName == scriptedType.RegisteredName());
- TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( scriptedName );
- DALI_TEST_CHECK( baseType );
+ TypeInfo baseType = TypeRegistry::Get().GetTypeInfo(scriptedName);
+ DALI_TEST_CHECK(baseType);
// should cause an assert because we're registering same type twice
// once statically at the start of this file, then again now
try
{
- TypeRegistration scriptedType( scriptedName, typeid(Dali::CustomActor), CreateCustomNamedInit );
- tet_result( TET_FAIL );
+ TypeRegistration scriptedType(scriptedName, typeid(Dali::CustomActor), CreateCustomNamedInit);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Duplicate type name in Type Registration", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Duplicate type name in Type Registration", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliTypeRegistrySignalConnectorTypeP(void)
{
ResetFunctorCounts();
TestApplication application;
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
- DALI_TEST_CHECK( type );
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyTestCustomActor");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
- MyTestCustomActor customHandle = MyTestCustomActor::DownCast( handle );
- DALI_TEST_CHECK( customHandle );
+ MyTestCustomActor customHandle = MyTestCustomActor::DownCast(handle);
+ DALI_TEST_CHECK(customHandle);
{
TestConnectionTracker tracker;
- bool connected = handle.ConnectSignal( &tracker, "sig1", CustomTestFunctor() );
- DALI_TEST_EQUALS( connected, true, TEST_LOCATION );
- DALI_TEST_CHECK( lastSignalConnectionCustom == "sig1" );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
+ bool connected = handle.ConnectSignal(&tracker, "sig1", CustomTestFunctor());
+ DALI_TEST_EQUALS(connected, true, TEST_LOCATION);
+ DALI_TEST_CHECK(lastSignalConnectionCustom == "sig1");
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION);
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION);
customHandle.GetCustomSignal().Emit();
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 1, TEST_LOCATION);
}
// tracker should automatically disconnect here
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION);
// Test that functor is disconnected
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 1, TEST_LOCATION);
customHandle.GetCustomSignal().Emit();
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 1/*not incremented*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 1 /*not incremented*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 0, TEST_LOCATION);
END_TEST;
}
TestApplication application;
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
- DALI_TEST_CHECK( type );
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyTestCustomActor");
+ DALI_TEST_CHECK(type);
- TypeInfo baseType = TypeRegistry::Get().GetTypeInfo( "CustomActor" );
- DALI_TEST_CHECK( baseType );
+ TypeInfo baseType = TypeRegistry::Get().GetTypeInfo("CustomActor");
+ DALI_TEST_CHECK(baseType);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
- MyTestCustomActor customHandle = MyTestCustomActor::DownCast( handle );
- DALI_TEST_CHECK( customHandle );
+ MyTestCustomActor customHandle = MyTestCustomActor::DownCast(handle);
+ DALI_TEST_CHECK(customHandle);
- DALI_TEST_EQUALS( type.GetActionCount(), TEST_ACTION_COUNT + baseType.GetActionCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(type.GetActionCount(), TEST_ACTION_COUNT + baseType.GetActionCount(), TEST_LOCATION);
- DALI_TEST_EQUALS( type.GetSignalCount(), TEST_SIGNAL_COUNT + baseType.GetSignalCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(type.GetSignalCount(), TEST_SIGNAL_COUNT + baseType.GetSignalCount(), TEST_LOCATION);
{
TestConnectionTracker tracker;
- bool connected = handle.ConnectSignal( &tracker, "sig2", CustomTestFunctor() );
- DALI_TEST_EQUALS( connected, false/*This is supposed to fail*/, TEST_LOCATION );
- DALI_TEST_CHECK( lastSignalConnectionCustom == "failed" );
- DALI_TEST_EQUALS( CustomTestFunctor::mTotalInstanceCount, 2/*temporary copy + FunctorDelegate copy*/, TEST_LOCATION );
- DALI_TEST_EQUALS( CustomTestFunctor::mCurrentInstanceCount, 0/*deleted along with FunctorDelegate*/, TEST_LOCATION );
+ bool connected = handle.ConnectSignal(&tracker, "sig2", CustomTestFunctor());
+ DALI_TEST_EQUALS(connected, false /*This is supposed to fail*/, TEST_LOCATION);
+ DALI_TEST_CHECK(lastSignalConnectionCustom == "failed");
+ DALI_TEST_EQUALS(CustomTestFunctor::mTotalInstanceCount, 2 /*temporary copy + FunctorDelegate copy*/, TEST_LOCATION);
+ DALI_TEST_EQUALS(CustomTestFunctor::mCurrentInstanceCount, 0 /*deleted along with FunctorDelegate*/, TEST_LOCATION);
// Should be a NOOP
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION);
customHandle.GetCustomSignal().Emit();
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0/*never called*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 0 /*never called*/, TEST_LOCATION);
}
// tracker should have nothing to disconnect here
// Should be a NOOP
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 0, TEST_LOCATION);
customHandle.GetCustomSignal().Emit();
- DALI_TEST_EQUALS( CustomTestFunctor::mCallbackCount, 0/*never called*/, TEST_LOCATION );
+ DALI_TEST_EQUALS(CustomTestFunctor::mCallbackCount, 0 /*never called*/, TEST_LOCATION);
END_TEST;
}
TestApplication application;
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
- DALI_TEST_CHECK( type );
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyTestCustomActor");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
Property::Map attributes;
- DALI_TEST_CHECK( handle.DoAction("act1", attributes) );
- DALI_TEST_CHECK( lastActionCustom == "act1" );
+ DALI_TEST_CHECK(handle.DoAction("act1", attributes));
+ DALI_TEST_CHECK(lastActionCustom == "act1");
END_TEST;
}
TestApplication application;
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( "MyTestCustomActor" );
- DALI_TEST_CHECK( type );
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo("MyTestCustomActor");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
+ DALI_TEST_CHECK(handle);
Property::Map attributes;
- DALI_TEST_CHECK( !handle.DoAction( "unknownAction", attributes ) );
+ DALI_TEST_CHECK(!handle.DoAction("unknownAction", attributes));
END_TEST;
}
int UtcDaliTypeRegistryPropertyRegistrationP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
- unsigned int initialPropertyCount( customActor.GetPropertyCount() );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
+ unsigned int initialPropertyCount(customActor.GetPropertyCount());
- std::string propertyName( "prop1" );
- int propertyIndex( PROPERTY_REGISTRATION_START_INDEX );
- Property::Type propertyType( Property::BOOLEAN );
- PropertyRegistration property1( customType1, propertyName, propertyIndex, propertyType, &SetProperty, &GetProperty );
+ std::string propertyName("prop1");
+ int propertyIndex(PROPERTY_REGISTRATION_START_INDEX);
+ Property::Type propertyType(Property::BOOLEAN);
+ PropertyRegistration property1(customType1, propertyName, propertyIndex, propertyType, &SetProperty, &GetProperty);
// Check property count after registration
- unsigned int postRegistrationPropertyCount( customActor.GetPropertyCount() );
- DALI_TEST_EQUALS( initialPropertyCount + 1u, postRegistrationPropertyCount, TEST_LOCATION );
+ unsigned int postRegistrationPropertyCount(customActor.GetPropertyCount());
+ DALI_TEST_EQUALS(initialPropertyCount + 1u, postRegistrationPropertyCount, TEST_LOCATION);
// Add custom property and check property count
- customActor.RegisterProperty( "customProp1", true );
- unsigned int customPropertyCount( customActor.GetPropertyCount() );
- DALI_TEST_EQUALS( postRegistrationPropertyCount + 1u, customPropertyCount, TEST_LOCATION );
+ customActor.RegisterProperty("customProp1", true);
+ unsigned int customPropertyCount(customActor.GetPropertyCount());
+ DALI_TEST_EQUALS(postRegistrationPropertyCount + 1u, customPropertyCount, TEST_LOCATION);
// Set the property, ensure SetProperty called
- DALI_TEST_CHECK( !setPropertyCalled );
- customActor.SetProperty( propertyIndex, false );
- DALI_TEST_CHECK( setPropertyCalled );
+ DALI_TEST_CHECK(!setPropertyCalled);
+ customActor.SetProperty(propertyIndex, false);
+ DALI_TEST_CHECK(setPropertyCalled);
// Get the property, ensure GetProperty called
- DALI_TEST_CHECK( !getPropertyCalled );
- (void)customActor.GetProperty< bool >( propertyIndex );
- DALI_TEST_CHECK( getPropertyCalled );
+ DALI_TEST_CHECK(!getPropertyCalled);
+ (void)customActor.GetProperty<bool>(propertyIndex);
+ DALI_TEST_CHECK(getPropertyCalled);
// Get the property using GetCurrentProperty and ensure GetProperty is called
getPropertyCalled = false;
- DALI_TEST_CHECK( !getPropertyCalled );
- customActor.GetCurrentProperty< bool >( propertyIndex );
- DALI_TEST_CHECK( getPropertyCalled );
+ DALI_TEST_CHECK(!getPropertyCalled);
+ customActor.GetCurrentProperty<bool>(propertyIndex);
+ DALI_TEST_CHECK(getPropertyCalled);
// Check the property name
- DALI_TEST_EQUALS( customActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
- DALI_TEST_EQUALS( typeInfo.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyName(propertyIndex), propertyName, TEST_LOCATION);
+ DALI_TEST_EQUALS(typeInfo.GetPropertyName(propertyIndex), propertyName, TEST_LOCATION);
// Check the property index
- DALI_TEST_EQUALS( customActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyIndex(propertyName), propertyIndex, TEST_LOCATION);
// Check the property type
- DALI_TEST_EQUALS( customActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyType(propertyIndex), propertyType, TEST_LOCATION);
// Check property count of type-info is 1
Property::IndexContainer indices;
- typeInfo.GetPropertyIndices( indices );
+ typeInfo.GetPropertyIndices(indices);
size_t typePropertyCount = typeInfo.GetPropertyCount();
- DALI_TEST_EQUALS( indices.Size(), Actor::New().GetPropertyCount() + 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( indices.Size(), typePropertyCount, TEST_LOCATION );
+ DALI_TEST_EQUALS(indices.Size(), Actor::New().GetPropertyCount() + 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(indices.Size(), typePropertyCount, TEST_LOCATION);
// Ensure indices returned from actor and customActor differ by two
Actor actor = Actor::New();
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
unsigned int actorIndices = indices.Size();
- customActor.GetPropertyIndices( indices );
+ customActor.GetPropertyIndices(indices);
unsigned int customActorIndices = indices.Size();
- DALI_TEST_EQUALS( actorIndices + 2u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
+ DALI_TEST_EQUALS(actorIndices + 2u, customActorIndices, TEST_LOCATION); // Custom property + registered property
END_TEST;
}
int UtcDaliTypeRegistryPropertyRegistrationN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Attempt to register a property type out-of-bounds index (less than)
try
{
- PropertyRegistration property1( customType1, "propName", PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN, &SetProperty, &GetProperty );
- tet_result( TET_FAIL );
+ PropertyRegistration property1(customType1, "propName", PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN, &SetProperty, &GetProperty);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= PROPERTY_REGISTRATION_START_INDEX ) && ( index <= PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= PROPERTY_REGISTRATION_START_INDEX) && (index <= PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
// Attempt to register a property type out-of-bounds index (greater than)
try
{
- PropertyRegistration property1( customType1, "propName", PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN, &SetProperty, &GetProperty );
- tet_result( TET_FAIL );
+ PropertyRegistration property1(customType1, "propName", PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN, &SetProperty, &GetProperty);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= PROPERTY_REGISTRATION_START_INDEX ) && ( index <= PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= PROPERTY_REGISTRATION_START_INDEX) && (index <= PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
END_TEST;
int UtcDaliTypeRegistryAnimatablePropertyRegistrationP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
application.GetScene().Add(customActor);
- unsigned int customPropertyCount( customActor.GetPropertyCount() );
+ unsigned int customPropertyCount(customActor.GetPropertyCount());
// Register animatable property
- std::string animatablePropertyName( "animatableProp1" );
- int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- Property::Type animatablePropertyType( Property::FLOAT );
- AnimatablePropertyRegistration animatableProperty( customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType );
+ std::string animatablePropertyName("animatableProp1");
+ int animatablePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ Property::Type animatablePropertyType(Property::FLOAT);
+ AnimatablePropertyRegistration animatableProperty(customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType);
// Check property count after registration
- DALI_TEST_EQUALS( customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION);
// Set the animatable property value
- customActor.SetProperty( animatablePropertyIndex, 25.0f );
+ customActor.SetProperty(animatablePropertyIndex, 25.0f);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 25.f, TEST_LOCATION);
// Check the animatable property name
- DALI_TEST_EQUALS( customActor.GetPropertyName( animatablePropertyIndex ), animatablePropertyName, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyName(animatablePropertyIndex), animatablePropertyName, TEST_LOCATION);
// Check the animatable property index
- DALI_TEST_EQUALS( customActor.GetPropertyIndex( animatablePropertyName ), animatablePropertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyIndex(animatablePropertyName), animatablePropertyIndex, TEST_LOCATION);
// Check the animatable property type
- DALI_TEST_EQUALS( customActor.GetPropertyType( animatablePropertyIndex ), animatablePropertyType, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyType(animatablePropertyIndex), animatablePropertyType, TEST_LOCATION);
// Check property count of type-info is 1
Property::IndexContainer indices;
- typeInfo.GetPropertyIndices( indices );
- DALI_TEST_EQUALS( indices.Size(), customActor.GetPropertyCount(), TEST_LOCATION );
+ typeInfo.GetPropertyIndices(indices);
+ DALI_TEST_EQUALS(indices.Size(), customActor.GetPropertyCount(), TEST_LOCATION);
// Ensure indices returned from actor and customActor differ by one
Actor actor = Actor::New();
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
unsigned int actorIndices = indices.Size();
- customActor.GetPropertyIndices( indices );
+ customActor.GetPropertyIndices(indices);
unsigned int customActorIndices = indices.Size();
- DALI_TEST_EQUALS( actorIndices + 1u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
+ DALI_TEST_EQUALS(actorIndices + 1u, customActorIndices, TEST_LOCATION); // Custom property + registered property
// check that the property is animatable
Animation animation = Animation::New(0.2f);
- animation.AnimateTo( Property( customActor, animatablePropertyIndex ), 15.f, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(customActor, animatablePropertyIndex), 15.f, AlphaFunction::LINEAR);
animation.Play();
// Target value should change straight away
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 15.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 15.0f, TEST_LOCATION);
// Render and notify, animation play for 0.05 seconds
application.SendNotification();
application.Render(50);
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 22.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyIndex), 22.5f, TEST_LOCATION);
// Render and notify, animation play for another 0.1 seconds
application.SendNotification();
application.Render(100);
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 17.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyIndex), 17.5f, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryAnimatablePropertyRegistrationN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Attempt to register an animatable property type out-of-bounds index (less than)
try
{
- AnimatablePropertyRegistration property1( customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
- tet_result( TET_FAIL );
+ AnimatablePropertyRegistration property1(customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
// Attempt to register an animatable property type out-of-bounds index (greater than)
try
{
- AnimatablePropertyRegistration property1( customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
- tet_result( TET_FAIL );
+ AnimatablePropertyRegistration property1(customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
END_TEST;
int UtcDaliTypeRegistryAnimatablePropertyRegistrationWithDefaultP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
application.GetScene().Add(customActor);
- unsigned int customPropertyCount( customActor.GetPropertyCount() );
+ unsigned int customPropertyCount(customActor.GetPropertyCount());
// Register animatable property
- std::string animatablePropertyName( "animatableProp1" );
- int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- AnimatablePropertyRegistration animatableProperty1( customType1, animatablePropertyName, animatablePropertyIndex, 10.f );
+ std::string animatablePropertyName("animatableProp1");
+ int animatablePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ AnimatablePropertyRegistration animatableProperty1(customType1, animatablePropertyName, animatablePropertyIndex, 10.f);
// Check property count after registration
- DALI_TEST_EQUALS( customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 10.f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 10.f, TEST_LOCATION);
// Check the animatable property name
- DALI_TEST_EQUALS( customActor.GetPropertyName( animatablePropertyIndex ), animatablePropertyName, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyName(animatablePropertyIndex), animatablePropertyName, TEST_LOCATION);
// Check the animatable property index
- DALI_TEST_EQUALS( customActor.GetPropertyIndex( animatablePropertyName ), animatablePropertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyIndex(animatablePropertyName), animatablePropertyIndex, TEST_LOCATION);
// Check the animatable property type
- DALI_TEST_EQUALS( customActor.GetPropertyType( animatablePropertyIndex ), Property::FLOAT, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyType(animatablePropertyIndex), Property::FLOAT, TEST_LOCATION);
// Check property count of type-info
Property::IndexContainer indices;
- typeInfo.GetPropertyIndices( indices );
- DALI_TEST_EQUALS( indices.Size(), customActor.GetPropertyCount(), TEST_LOCATION );
+ typeInfo.GetPropertyIndices(indices);
+ DALI_TEST_EQUALS(indices.Size(), customActor.GetPropertyCount(), TEST_LOCATION);
// Ensure indices returned from actor and customActor differ by one
Actor actor = Actor::New();
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
unsigned int actorIndices = indices.Size();
- customActor.GetPropertyIndices( indices );
+ customActor.GetPropertyIndices(indices);
unsigned int customActorIndices = indices.Size();
- DALI_TEST_EQUALS( actorIndices + 1u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
+ DALI_TEST_EQUALS(actorIndices + 1u, customActorIndices, TEST_LOCATION); // Custom property + registered property
// check that the property is animatable
Animation animation = Animation::New(0.2f);
- animation.AnimateTo( Property( customActor, animatablePropertyIndex ), 20.f, AlphaFunction::LINEAR );
+ animation.AnimateTo(Property(customActor, animatablePropertyIndex), 20.f, AlphaFunction::LINEAR);
animation.Play();
// Target value should change straight away
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 20.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 20.0f, TEST_LOCATION);
// Render and notify, animation play for 0.05 seconds
application.SendNotification();
application.Render(50);
- DALI_TEST_EQUALS( 0.25f, animation.GetCurrentProgress(), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 12.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.25f, animation.GetCurrentProgress(), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyIndex), 12.5f, TEST_LOCATION);
// Render and notify, animation play for another 0.1 seconds
application.SendNotification();
application.Render(100);
- DALI_TEST_EQUALS( 0.75f, animation.GetCurrentProgress(), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 17.5f, TEST_LOCATION );
+ DALI_TEST_EQUALS(0.75f, animation.GetCurrentProgress(), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyIndex), 17.5f, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryAnimatablePropertyRegistrationWithDefaultN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Attempt to register an animatable property type out-of-bounds index (less than)
try
{
- AnimatablePropertyRegistration property1( customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, false );
- tet_result( TET_FAIL );
+ AnimatablePropertyRegistration property1(customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, false);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
// Attempt to register an animatable property type out-of-bounds index (greater than)
try
{
- AnimatablePropertyRegistration property1( customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, true );
- tet_result( TET_FAIL );
+ AnimatablePropertyRegistration property1(customType1, "animPropName", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, true);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
END_TEST;
int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
- unsigned int customPropertyCount( customActor.GetPropertyCount() );
+ unsigned int customPropertyCount(customActor.GetPropertyCount());
// Register animatable property
- std::string animatablePropertyName( "animatableProp1" );
- int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- Property::Type animatablePropertyType( Property::VECTOR2 );
- AnimatablePropertyRegistration animatableProperty1( customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType );
+ std::string animatablePropertyName("animatableProp1");
+ int animatablePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ Property::Type animatablePropertyType(Property::VECTOR2);
+ AnimatablePropertyRegistration animatableProperty1(customType1, animatablePropertyName, animatablePropertyIndex, animatablePropertyType);
// Check property count after registration
- DALI_TEST_EQUALS( customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(customPropertyCount + 1u, customActor.GetPropertyCount(), TEST_LOCATION);
// Set the animatable property value
- customActor.SetProperty( animatablePropertyIndex, Vector2(25.0f, 50.0f) );
+ customActor.SetProperty(animatablePropertyIndex, Vector2(25.0f, 50.0f));
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( animatablePropertyIndex ), Vector2(25.0f, 50.0f), TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(animatablePropertyIndex), Vector2(25.0f, 50.0f), TEST_LOCATION);
// Check the animatable property name
- DALI_TEST_EQUALS( customActor.GetPropertyName( animatablePropertyIndex ), animatablePropertyName, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyName(animatablePropertyIndex), animatablePropertyName, TEST_LOCATION);
// Check the animatable property index
- DALI_TEST_EQUALS( customActor.GetPropertyIndex( animatablePropertyName ), animatablePropertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyIndex(animatablePropertyName), animatablePropertyIndex, TEST_LOCATION);
// Check the animatable property type
- DALI_TEST_EQUALS( customActor.GetPropertyType( animatablePropertyIndex ), animatablePropertyType, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetPropertyType(animatablePropertyIndex), animatablePropertyType, TEST_LOCATION);
// Check property count of type-info
Property::IndexContainer indices;
- typeInfo.GetPropertyIndices( indices );
- DALI_TEST_EQUALS( indices.Size(), customActor.GetPropertyCount(), TEST_LOCATION );
+ typeInfo.GetPropertyIndices(indices);
+ DALI_TEST_EQUALS(indices.Size(), customActor.GetPropertyCount(), TEST_LOCATION);
// Register animatable property components
- std::string animatablePropertyComponentName1( "animatableProp1X" );
- int animatablePropertyComponentIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, animatablePropertyComponentName1, animatablePropertyComponentIndex1, animatablePropertyIndex, 0 );
+ std::string animatablePropertyComponentName1("animatableProp1X");
+ int animatablePropertyComponentIndex1(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent1(customType1, animatablePropertyComponentName1, animatablePropertyComponentIndex1, animatablePropertyIndex, 0);
- std::string animatablePropertyComponentName2( "animatableProp1Y" );
- int animatablePropertyComponentIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, animatablePropertyComponentName2, animatablePropertyComponentIndex2, animatablePropertyIndex, 1 );
+ std::string animatablePropertyComponentName2("animatableProp1Y");
+ int animatablePropertyComponentIndex2(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent2(customType1, animatablePropertyComponentName2, animatablePropertyComponentIndex2, animatablePropertyIndex, 1);
// Check property count after registration
- DALI_TEST_EQUALS( customPropertyCount + 3u, customActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(customPropertyCount + 3u, customActor.GetPropertyCount(), TEST_LOCATION);
// Check the animatable property component value
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex1 ), 25.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex2 ), 50.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyComponentIndex1), 25.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyComponentIndex2), 50.0f, TEST_LOCATION);
// Set the animatable property component value
- customActor.SetProperty( animatablePropertyComponentIndex1, 150.0f );
+ customActor.SetProperty(animatablePropertyComponentIndex1, 150.0f);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( animatablePropertyIndex ), Vector2(150.0f, 50.0f), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex1 ), 150.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex2 ), 50.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector2>(animatablePropertyIndex), Vector2(150.0f, 50.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyComponentIndex1), 150.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyComponentIndex2), 50.0f, TEST_LOCATION);
// Set the animatable property component value
- customActor.SetProperty( animatablePropertyComponentIndex2, 225.0f );
+ customActor.SetProperty(animatablePropertyComponentIndex2, 225.0f);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( animatablePropertyIndex ), Vector2(150.0f, 225.0f), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex1 ), 150.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyComponentIndex2 ), 225.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector2>(animatablePropertyIndex), Vector2(150.0f, 225.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyComponentIndex1), 150.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyComponentIndex2), 225.0f, TEST_LOCATION);
// Ensure indices returned from actor and customActor differ by three
Actor actor = Actor::New();
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
unsigned int actorIndices = indices.Size();
- customActor.GetPropertyIndices( indices );
+ customActor.GetPropertyIndices(indices);
unsigned int customActorIndices = indices.Size();
- DALI_TEST_EQUALS( actorIndices + 3u, customActorIndices, TEST_LOCATION ); // Custom property + registered property
+ DALI_TEST_EQUALS(actorIndices + 3u, customActorIndices, TEST_LOCATION); // Custom property + registered property
+
+ application.GetScene().Add(customActor);
// Attempt to animate component property, it should not crash
- Animation animation = Animation::New( 1.0f );
- animation.AnimateTo( Property( customActor, animatablePropertyComponentIndex1 ), 200.0f );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateTo(Property(customActor, animatablePropertyComponentIndex1), 200.0f);
animation.Play();
// Check the property value
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( animatablePropertyIndex ), Vector2(200.0f, 225.0f), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyComponentIndex1 ), 200.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyComponentIndex2 ), 225.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(animatablePropertyIndex), Vector2(200.0f, 225.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyComponentIndex1), 200.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyComponentIndex2), 225.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationVector2AnimateByP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ application.GetScene().Add(customActor);
+ DALI_TEST_CHECK(customActor);
- const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
+ const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
const unsigned int xComponentIndex = index + 1;
const unsigned int yComponentIndex = index + 2;
- const Vector2 initialValue( 20.0f, 40.0f );
+ const Vector2 initialValue(20.0f, 40.0f);
// Register animatable property & its components
- AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", index, initialValue );
- AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, "animatableProp1X", xComponentIndex, index, 0 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, "animatableProp1Y", yComponentIndex, index, 1 );
+ AnimatablePropertyRegistration animatableProperty1(customType1, "animatableProp1", index, initialValue);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent1(customType1, "animatableProp1X", xComponentIndex, index, 0);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent2(customType1, "animatableProp1Y", yComponentIndex, index, 1);
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( index ), initialValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(index), initialValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(xComponentIndex), initialValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(yComponentIndex), initialValue.y, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property current value
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( index ), initialValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector2>(index), initialValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(xComponentIndex), initialValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(yComponentIndex), initialValue.y, TEST_LOCATION);
// Do an AnimateBy
- const Vector2 targetValue( 45.0f, 53.0f );
- const Vector2 relativeValue( targetValue - initialValue );
+ const Vector2 targetValue(45.0f, 53.0f);
+ const Vector2 relativeValue(targetValue - initialValue);
- Animation animation = Animation::New( 1.0f );
- animation.AnimateBy( Property( customActor, xComponentIndex ), relativeValue.x );
- animation.AnimateBy( Property( customActor, yComponentIndex ), relativeValue.y );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(customActor, xComponentIndex), relativeValue.x);
+ animation.AnimateBy(Property(customActor, yComponentIndex), relativeValue.y);
animation.Play();
// Target values should change straight away
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), targetValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), targetValue.y, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(xComponentIndex), targetValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(yComponentIndex), targetValue.y, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationVector3AnimateByP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ application.GetScene().Add(customActor);
+ DALI_TEST_CHECK(customActor);
- const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
+ const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
const unsigned int xComponentIndex = index + 1;
const unsigned int yComponentIndex = index + 2;
const unsigned int zComponentIndex = index + 3;
- const Vector3 initialValue( 20.0f, 40.0f, 50.0f );
+ const Vector3 initialValue(20.0f, 40.0f, 50.0f);
// Register animatable property & its components
- AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", index, initialValue );
- AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, "animatableProp1X", xComponentIndex, index, 0 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, "animatableProp1Y", yComponentIndex, index, 1 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent3( customType1, "animatableProp1Z", zComponentIndex, index, 2 );
+ AnimatablePropertyRegistration animatableProperty1(customType1, "animatableProp1", index, initialValue);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent1(customType1, "animatableProp1X", xComponentIndex, index, 0);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent2(customType1, "animatableProp1Y", yComponentIndex, index, 1);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent3(customType1, "animatableProp1Z", zComponentIndex, index, 2);
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( index ), initialValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(index), initialValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(xComponentIndex), initialValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(yComponentIndex), initialValue.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(zComponentIndex), initialValue.z, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property current value
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( index ), initialValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector3>(index), initialValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(xComponentIndex), initialValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(yComponentIndex), initialValue.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(zComponentIndex), initialValue.z, TEST_LOCATION);
// Do an AnimateBy
- const Vector3 targetValue( 45.0f, 53.0f, 25.0f );
- const Vector3 relativeValue( targetValue - initialValue );
+ const Vector3 targetValue(45.0f, 53.0f, 25.0f);
+ const Vector3 relativeValue(targetValue - initialValue);
- Animation animation = Animation::New( 1.0f );
- animation.AnimateBy( Property( customActor, xComponentIndex ), relativeValue.x );
- animation.AnimateBy( Property( customActor, yComponentIndex ), relativeValue.y );
- animation.AnimateBy( Property( customActor, zComponentIndex ), relativeValue.z );
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(customActor, xComponentIndex), relativeValue.x);
+ animation.AnimateBy(Property(customActor, yComponentIndex), relativeValue.y);
+ animation.AnimateBy(Property(customActor, zComponentIndex), relativeValue.z);
animation.Play();
// Target values should change straight away
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), targetValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), targetValue.y, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), targetValue.z, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(xComponentIndex), targetValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(yComponentIndex), targetValue.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(zComponentIndex), targetValue.z, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationVector4AnimateByP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ application.GetScene().Add(customActor);
+ DALI_TEST_CHECK(customActor);
- const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
+ const unsigned int index = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX;
const unsigned int xComponentIndex = index + 1;
const unsigned int yComponentIndex = index + 2;
const unsigned int zComponentIndex = index + 3;
const unsigned int wComponentIndex = index + 4;
- const Vector4 initialValue( 20.0f, 40.0f, 50.0f, 60.0f );
+ const Vector4 initialValue(20.0f, 40.0f, 50.0f, 60.0f);
// Register animatable property & its components
- AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", index, initialValue );
- AnimatablePropertyComponentRegistration animatablePropertyComponent1( customType1, "animatableProp1X", xComponentIndex, index, 0 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent2( customType1, "animatableProp1Y", yComponentIndex, index, 1 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent3( customType1, "animatableProp1Z", zComponentIndex, index, 2 );
- AnimatablePropertyComponentRegistration animatablePropertyComponent4( customType1, "animatableProp1W", wComponentIndex, index, 3 );
+ AnimatablePropertyRegistration animatableProperty1(customType1, "animatableProp1", index, initialValue);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent1(customType1, "animatableProp1X", xComponentIndex, index, 0);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent2(customType1, "animatableProp1Y", yComponentIndex, index, 1);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent3(customType1, "animatableProp1Z", zComponentIndex, index, 2);
+ AnimatablePropertyComponentRegistration animatablePropertyComponent4(customType1, "animatableProp1W", wComponentIndex, index, 3);
// Check the animatable property value
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( index ), initialValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( wComponentIndex ), initialValue.w, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(index), initialValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(xComponentIndex), initialValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(yComponentIndex), initialValue.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(zComponentIndex), initialValue.z, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(wComponentIndex), initialValue.w, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
// Check the animatable property current value
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( index ), initialValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( xComponentIndex ), initialValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( yComponentIndex ), initialValue.y, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( zComponentIndex ), initialValue.z, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( wComponentIndex ), initialValue.w, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector4>(index), initialValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(xComponentIndex), initialValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(yComponentIndex), initialValue.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(zComponentIndex), initialValue.z, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(wComponentIndex), initialValue.w, TEST_LOCATION);
// Do an AnimateBy
- const Vector4 targetValue( 45.0f, 53.0f, 25.0f, 13.0f );
- const Vector4 relativeValue( targetValue - initialValue );
-
- Animation animation = Animation::New( 1.0f );
- animation.AnimateBy( Property( customActor, xComponentIndex ), relativeValue.x );
- animation.AnimateBy( Property( customActor, yComponentIndex ), relativeValue.y );
- animation.AnimateBy( Property( customActor, zComponentIndex ), relativeValue.z );
- animation.AnimateBy( Property( customActor, wComponentIndex ), relativeValue.w );
+ const Vector4 targetValue(45.0f, 53.0f, 25.0f, 13.0f);
+ const Vector4 relativeValue(targetValue - initialValue);
+
+ Animation animation = Animation::New(1.0f);
+ animation.AnimateBy(Property(customActor, xComponentIndex), relativeValue.x);
+ animation.AnimateBy(Property(customActor, yComponentIndex), relativeValue.y);
+ animation.AnimateBy(Property(customActor, zComponentIndex), relativeValue.z);
+ animation.AnimateBy(Property(customActor, wComponentIndex), relativeValue.w);
animation.Play();
// Target values should change straight away
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( index ), targetValue, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( xComponentIndex ), targetValue.x, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( yComponentIndex ), targetValue.y, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( zComponentIndex ), targetValue.z, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( wComponentIndex ), targetValue.w, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(index), targetValue, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(xComponentIndex), targetValue.x, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(yComponentIndex), targetValue.y, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(zComponentIndex), targetValue.z, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(wComponentIndex), targetValue.w, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryAnimatablePropertyComponentRegistrationN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Register animatable property with the type of Vector2
- int animatablePropertyIndex1( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- AnimatablePropertyRegistration animatableProperty1( customType1, "animatableProp1", animatablePropertyIndex1, Property::VECTOR2 );
+ int animatablePropertyIndex1(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ AnimatablePropertyRegistration animatableProperty1(customType1, "animatableProp1", animatablePropertyIndex1, Property::VECTOR2);
// Attempt to register an animatable property component out-of-bounds index (less than)
try
{
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, animatablePropertyIndex1, 0 );
- tet_result( TET_FAIL );
+ AnimatablePropertyComponentRegistration propertyComponent1(customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX - 1, animatablePropertyIndex1, 0);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
// Attempt to register an animatable property component out-of-bounds index (greater than)
try
{
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, animatablePropertyIndex1, 0 );
- tet_result( TET_FAIL );
+ AnimatablePropertyComponentRegistration propertyComponent1(customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX + 1, animatablePropertyIndex1, 0);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
// Register an animatable property component
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1, animatablePropertyIndex1, 0 );
+ AnimatablePropertyComponentRegistration propertyComponent1(customType1, "animatableProp1X", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 1, animatablePropertyIndex1, 0);
// Attempt to register another animatable property component with the same component index
try
{
- AnimatablePropertyComponentRegistration propertyComponent2( customType1, "animatableProp1Y", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2, animatablePropertyIndex1, 0 );
- tet_result( TET_FAIL );
+ AnimatablePropertyComponentRegistration propertyComponent2(customType1, "animatableProp1Y", ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2, animatablePropertyIndex1, 0);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property component already registered", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property component already registered", TEST_LOCATION);
}
// Register animatable property with the type of boolean
- int animatablePropertyIndex2( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2 );
- AnimatablePropertyRegistration animatableProperty2( customType1, "animatableProp2", animatablePropertyIndex2, Property::BOOLEAN );
+ int animatablePropertyIndex2(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2);
+ AnimatablePropertyRegistration animatableProperty2(customType1, "animatableProp2", animatablePropertyIndex2, Property::BOOLEAN);
// Attempt to register an animatable property component for the above property with boolean type
try
{
- AnimatablePropertyComponentRegistration propertyComponent1( customType1, "animatableProp2X", animatablePropertyIndex2 + 1, animatablePropertyIndex2, 0 );
- tet_result( TET_FAIL );
+ AnimatablePropertyComponentRegistration propertyComponent1(customType1, "animatableProp2X", animatablePropertyIndex2 + 1, animatablePropertyIndex2, 0);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "Base property does not support component", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Base property does not support component", TEST_LOCATION);
}
END_TEST;
int UtcDaliTypeRegistryChildPropertyRegistrationP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
- unsigned int initialPropertyCount( customActor.GetPropertyCount() );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
+ unsigned int initialPropertyCount(customActor.GetPropertyCount());
// Register child properties to the parent
- std::string propertyName( "childProp1" );
- int propertyIndex( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- Property::Type propertyType( Property::BOOLEAN );
- ChildPropertyRegistration childProperty1( customType1, propertyName, propertyIndex, propertyType );
-
- std::string propertyName2( "childProp2" );
- int propertyIndex2( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1 );
- Property::Type propertyType2( Property::INTEGER );
- ChildPropertyRegistration childProperty2( customType1, propertyName2, propertyIndex2, propertyType2 );
-
- std::string propertyName3( "childProp3" );
- int propertyIndex3( CHILD_PROPERTY_REGISTRATION_START_INDEX + 2 );
- Property::Type propertyType3( Property::FLOAT );
- ChildPropertyRegistration childProperty3( customType1, propertyName3, propertyIndex3, propertyType3 );
-
- std::string propertyName4( "childProp4" );
- int propertyIndex4( CHILD_PROPERTY_REGISTRATION_START_INDEX + 3 );
- Property::Type propertyType4( Property::INTEGER );
- ChildPropertyRegistration childProperty4( customType1, propertyName4, propertyIndex4, propertyType4 );
+ std::string propertyName("childProp1");
+ int propertyIndex(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ Property::Type propertyType(Property::BOOLEAN);
+ ChildPropertyRegistration childProperty1(customType1, propertyName, propertyIndex, propertyType);
+
+ std::string propertyName2("childProp2");
+ int propertyIndex2(CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
+ Property::Type propertyType2(Property::INTEGER);
+ ChildPropertyRegistration childProperty2(customType1, propertyName2, propertyIndex2, propertyType2);
+
+ std::string propertyName3("childProp3");
+ int propertyIndex3(CHILD_PROPERTY_REGISTRATION_START_INDEX + 2);
+ Property::Type propertyType3(Property::FLOAT);
+ ChildPropertyRegistration childProperty3(customType1, propertyName3, propertyIndex3, propertyType3);
+
+ std::string propertyName4("childProp4");
+ int propertyIndex4(CHILD_PROPERTY_REGISTRATION_START_INDEX + 3);
+ Property::Type propertyType4(Property::INTEGER);
+ ChildPropertyRegistration childProperty4(customType1, propertyName4, propertyIndex4, propertyType4);
// Check property count are not changed because the child properties will not be created for the parent
- DALI_TEST_EQUALS( initialPropertyCount, customActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialPropertyCount, customActor.GetPropertyCount(), TEST_LOCATION);
// check the child property type
- Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
- Property::Type type = typeInfoImpl.GetChildPropertyType( typeInfoImpl.GetChildPropertyIndex("childProp4") );
- DALI_TEST_EQUALS( type, Property::INTEGER, TEST_LOCATION );
+ Internal::TypeInfo& typeInfoImpl = GetImplementation(typeInfo);
+ Property::Type type = typeInfoImpl.GetChildPropertyType(typeInfoImpl.GetChildPropertyIndex("childProp4"));
+ DALI_TEST_EQUALS(type, Property::INTEGER, TEST_LOCATION);
- std::string unRegisteredChildName( typeInfoImpl.GetChildPropertyName( CHILD_PROPERTY_REGISTRATION_START_INDEX + 4 ) );
- DALI_TEST_EQUALS( unRegisteredChildName, "", TEST_LOCATION );
+ std::string unRegisteredChildName(typeInfoImpl.GetChildPropertyName(CHILD_PROPERTY_REGISTRATION_START_INDEX + 4));
+ DALI_TEST_EQUALS(unRegisteredChildName, "", TEST_LOCATION);
// Create a child actor
Actor childActor = Actor::New();
- DALI_TEST_CHECK( childActor );
- unsigned int initialChildActorPropertyCount( childActor.GetPropertyCount() );
+ DALI_TEST_CHECK(childActor);
+ unsigned int initialChildActorPropertyCount(childActor.GetPropertyCount());
// The type of child properties should be Property::None as the child hasn't registered any child property yet.
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), Property::NONE, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex2 ), Property::NONE, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex3 ), Property::NONE, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex4 ), Property::NONE, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex), Property::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex2), Property::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex3), Property::NONE, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex4), Property::NONE, TEST_LOCATION);
// Set the value for the first child property when the child actor doesn't have a parent yet
childActor.SetProperty(propertyIndex, true);
// Check that the first child property is dynamically created
- DALI_TEST_EQUALS( initialChildActorPropertyCount + 1u, childActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialChildActorPropertyCount + 1u, childActor.GetPropertyCount(), TEST_LOCATION);
// Check the first child property value
- DALI_TEST_EQUALS( childActor.GetProperty< bool >( propertyIndex ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetProperty<bool>(propertyIndex), true, TEST_LOCATION);
// Check the first child property type
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex), propertyType, TEST_LOCATION);
// Check that the first child property have no name, as it doesn't have a parent yet.
- DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), "", TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyName(propertyIndex), "", TEST_LOCATION);
// Check that the first property can't be accessed through its name, as it doesn't have a parent yet.
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), Property::INVALID_INDEX, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName), Property::INVALID_INDEX, TEST_LOCATION);
// Create a custom property for the child with the same name as the second child property registered to the parent
Property::Index customPropertyIndex = childActor.RegisterProperty(propertyName2, 100, Property::READ_WRITE);
// Check that the custom property is created
- DALI_TEST_EQUALS( initialChildActorPropertyCount + 2u, childActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialChildActorPropertyCount + 2u, childActor.GetPropertyCount(), TEST_LOCATION);
// Check the property value
- DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex ), 100, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetProperty<int>(customPropertyIndex), 100, TEST_LOCATION);
// Check the property index
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName2 ), customPropertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName2), customPropertyIndex, TEST_LOCATION);
// Check the property type
- DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex ), propertyType2, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(customPropertyIndex), propertyType2, TEST_LOCATION);
// Check the property name
- DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex ), propertyName2, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyName(customPropertyIndex), propertyName2, TEST_LOCATION);
// Now add the child actor to the parent
- customActor.Add( childActor );
+ customActor.Add(childActor);
// Check that the first child property now has the correct name as previously registered to the parent
- DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyName(propertyIndex), propertyName, TEST_LOCATION);
// Check that the child property index for the first child property can now be retrieved through its child property name
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName), propertyIndex, TEST_LOCATION);
// Check that the second child property now has the correct index as previously registered to the parent
- DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex2 ), propertyName2, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyName(propertyIndex2), propertyName2, TEST_LOCATION);
// Check that the second child property can be accessed through both its custom property index and its child property index
- DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex ), 100, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetProperty< int >( propertyIndex2 ), 100, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex ), propertyType2, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex2 ), propertyType2, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetProperty<int>(customPropertyIndex), 100, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetProperty<int>(propertyIndex2), 100, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(customPropertyIndex), propertyType2, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex2), propertyType2, TEST_LOCATION);
// Check that the child property index for the second child property can now be retrieved through its child property name
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName2 ), propertyIndex2, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName2), propertyIndex2, TEST_LOCATION);
// Set the value for the third child property when the child actor is already added to the parent
childActor.SetProperty(propertyIndex3, 0.15f);
// Check that the third child property is dynamically created
- DALI_TEST_EQUALS( initialChildActorPropertyCount + 3u, childActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialChildActorPropertyCount + 3u, childActor.GetPropertyCount(), TEST_LOCATION);
// Check the third child property value
- DALI_TEST_EQUALS( childActor.GetProperty< float >( propertyIndex3 ), 0.15f, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetProperty<float>(propertyIndex3), 0.15f, TEST_LOCATION);
// Check the third child property type
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex3 ), propertyType3, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex3), propertyType3, TEST_LOCATION);
// Check the third child property name
- DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex3 ), propertyName3, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyName(propertyIndex3), propertyName3, TEST_LOCATION);
// Check the third child property index.
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName3 ), propertyIndex3, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName3), propertyIndex3, TEST_LOCATION);
// Create a custom property for the child with the same name as the fourth child property registered to the parent
Property::Index customPropertyIndex2 = childActor.RegisterProperty(propertyName4, 20, Property::READ_WRITE);
// Check that the custom property is created
- DALI_TEST_EQUALS( initialChildActorPropertyCount + 4u, childActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialChildActorPropertyCount + 4u, childActor.GetPropertyCount(), TEST_LOCATION);
// Check the fourth child property value
- DALI_TEST_EQUALS( childActor.GetProperty< int >( propertyIndex4 ), 20, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetProperty< int >( customPropertyIndex2 ), 20, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetProperty<int>(propertyIndex4), 20, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetProperty<int>(customPropertyIndex2), 20, TEST_LOCATION);
// Check the fourth child property type
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex4 ), propertyType4, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex2 ), propertyType4, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex4), propertyType4, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(customPropertyIndex2), propertyType4, TEST_LOCATION);
// Check the fourth child property name
- DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex4 ), propertyName4, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex2 ), propertyName4, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyName(propertyIndex4), propertyName4, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyName(customPropertyIndex2), propertyName4, TEST_LOCATION);
// Check the fourth child property index.
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName4 ), propertyIndex4, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName4), propertyIndex4, TEST_LOCATION);
// Now create another parent actor with different child properties registered
- TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyNamedActor" );
- DALI_TEST_CHECK( typeInfo2 );
+ TypeInfo typeInfo2 = typeRegistry.GetTypeInfo("MyNamedActor");
+ DALI_TEST_CHECK(typeInfo2);
BaseHandle handle2 = typeInfo2.CreateInstance();
- DALI_TEST_CHECK( handle2 );
- Actor customActor2 = Actor::DownCast( handle2 );
- DALI_TEST_CHECK( customActor2 );
+ DALI_TEST_CHECK(handle2);
+ Actor customActor2 = Actor::DownCast(handle2);
+ DALI_TEST_CHECK(customActor2);
// Register child properties to the new parent
- std::string newPropertyName( "newChildProp" );
- int newPropertyIndex( CHILD_PROPERTY_REGISTRATION_START_INDEX ); // The same index as the first child property "childProp1" in the old parent
- Property::Type newPropertyType( Property::VECTOR2 );
- ChildPropertyRegistration newChildProperty( namedActorType, newPropertyName, newPropertyIndex, newPropertyType );
+ std::string newPropertyName("newChildProp");
+ int newPropertyIndex(CHILD_PROPERTY_REGISTRATION_START_INDEX); // The same index as the first child property "childProp1" in the old parent
+ Property::Type newPropertyType(Property::VECTOR2);
+ ChildPropertyRegistration newChildProperty(namedActorType, newPropertyName, newPropertyIndex, newPropertyType);
- std::string newPropertyName2( "childProp3" ); // The same name as the third child property in the old parent
- int newPropertyIndex2( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1 ); // The same index as the second child property "childProp2" in the old parent
- Property::Type newPropertyType2( Property::FLOAT ); // The same type as the third child property in the old parent
- ChildPropertyRegistration newChildProperty2( namedActorType, newPropertyName2, newPropertyIndex2, newPropertyType2 );
+ std::string newPropertyName2("childProp3"); // The same name as the third child property in the old parent
+ int newPropertyIndex2(CHILD_PROPERTY_REGISTRATION_START_INDEX + 1); // The same index as the second child property "childProp2" in the old parent
+ Property::Type newPropertyType2(Property::FLOAT); // The same type as the third child property in the old parent
+ ChildPropertyRegistration newChildProperty2(namedActorType, newPropertyName2, newPropertyIndex2, newPropertyType2);
// Now move the child actor to the new parent
- customActor2.Add( childActor );
+ customActor2.Add(childActor);
// "childProp1" is not a valid child property supported by the new parent, so nothing changed
- DALI_TEST_EQUALS( childActor.GetPropertyType( propertyIndex ), propertyType, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyName( propertyIndex ), propertyName, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( propertyName ), propertyIndex, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(propertyIndex), propertyType, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyName(propertyIndex), propertyName, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(propertyName), propertyIndex, TEST_LOCATION);
// "childProp3" is a valid child property supported by the new parent
// So it should get its new child property index and should just work
- DALI_TEST_EQUALS( childActor.GetPropertyType( newPropertyIndex2 ), newPropertyType2, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyName( newPropertyIndex2 ), newPropertyName2, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( newPropertyName2 ), newPropertyIndex2, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetProperty< float >( newPropertyIndex2 ), 0.15f, TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(newPropertyIndex2), newPropertyType2, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyName(newPropertyIndex2), newPropertyName2, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(newPropertyName2), newPropertyIndex2, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetProperty<float>(newPropertyIndex2), 0.15f, TEST_LOCATION);
// Now register a custom property called "newChildProp"
- Property::Index customPropertyIndex3 = childActor.RegisterProperty("newChildProp", Vector2( 10.0f, 10.0f ), Property::READ_WRITE);
+ Property::Index customPropertyIndex3 = childActor.RegisterProperty("newChildProp", Vector2(10.0f, 10.0f), Property::READ_WRITE);
// Check that the custom property is created
- DALI_TEST_EQUALS( initialChildActorPropertyCount + 5u, childActor.GetPropertyCount(), TEST_LOCATION );
+ DALI_TEST_EQUALS(initialChildActorPropertyCount + 5u, childActor.GetPropertyCount(), TEST_LOCATION);
// This is a valid child property registered to the new parent
// So should be able to access it through both its custom property index and its registered child property index
- DALI_TEST_EQUALS( childActor.GetPropertyType( newPropertyIndex ), newPropertyType, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyType( customPropertyIndex3 ), newPropertyType, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetPropertyName( newPropertyIndex ), newPropertyName, TEST_LOCATION ); // This should return the new name, although the child property index remains the same
- DALI_TEST_EQUALS( childActor.GetPropertyName( customPropertyIndex3 ), newPropertyName, TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetProperty< Vector2 >( newPropertyIndex ), Vector2( 10.0f, 10.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( childActor.GetProperty< Vector2 >( customPropertyIndex3 ), Vector2( 10.0f, 10.0f ), TEST_LOCATION );
+ DALI_TEST_EQUALS(childActor.GetPropertyType(newPropertyIndex), newPropertyType, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyType(customPropertyIndex3), newPropertyType, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetPropertyName(newPropertyIndex), newPropertyName, TEST_LOCATION); // This should return the new name, although the child property index remains the same
+ DALI_TEST_EQUALS(childActor.GetPropertyName(customPropertyIndex3), newPropertyName, TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetProperty<Vector2>(newPropertyIndex), Vector2(10.0f, 10.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(childActor.GetProperty<Vector2>(customPropertyIndex3), Vector2(10.0f, 10.0f), TEST_LOCATION);
// Should return the child property index by given its name
- DALI_TEST_EQUALS( childActor.GetPropertyIndex( newPropertyName ), newPropertyIndex, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(childActor.GetPropertyIndex(newPropertyName), newPropertyIndex, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeRegistryChildPropertyRegistrationN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Attempt to register a child property type out-of-bounds index (less than)
try
{
- ChildPropertyRegistration property1( customType1, "propName", CHILD_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN );
- tet_result( TET_FAIL );
+ ChildPropertyRegistration property1(customType1, "propName", CHILD_PROPERTY_REGISTRATION_START_INDEX - 1, Property::BOOLEAN);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= CHILD_PROPERTY_REGISTRATION_START_INDEX) && (index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
// Attempt to register a child property type out-of-bounds index (greater than)
try
{
- ChildPropertyRegistration property1( customType1, "propName", CHILD_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN );
- tet_result( TET_FAIL );
+ ChildPropertyRegistration property1(customType1, "propName", CHILD_PROPERTY_REGISTRATION_MAX_INDEX + 1, Property::BOOLEAN);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX )", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "(index >= CHILD_PROPERTY_REGISTRATION_START_INDEX) && (index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX)", TEST_LOCATION);
}
END_TEST;
}
-
/*******************************************************************************
*
* Action through the base handle
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("Actor");
+ DALI_TEST_CHECK(type);
BaseHandle hdl = type.CreateInstance();
- DALI_TEST_CHECK( hdl );
+ DALI_TEST_CHECK(hdl);
Actor a = Actor::DownCast(hdl);
- DALI_TEST_CHECK( a );
+ DALI_TEST_CHECK(a);
- a.SetProperty( Actor::Property::VISIBLE,false);
+ a.SetProperty(Actor::Property::VISIBLE, false);
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK(!a.GetCurrentProperty< bool >( Actor::Property::VISIBLE ));
+ DALI_TEST_CHECK(!a.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
Property::Map attributes;
application.SendNotification();
application.Render(0);
- DALI_TEST_CHECK(a.GetCurrentProperty< bool >( Actor::Property::VISIBLE ));
+ DALI_TEST_CHECK(a.GetCurrentProperty<bool>(Actor::Property::VISIBLE));
- DALI_TEST_CHECK(!hdl.DoAction("unknownAction", attributes));
+ DALI_TEST_CHECK(!hdl.DoAction("unknownAction", attributes));
END_TEST;
}
int UtcDaliPropertyRegistrationFunctions(void)
{
TestApplication application;
- int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 10;
+ int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 10;
// Attempt to register a property without a setter
try
{
- PropertyRegistration property1( customType1, "propName", propertyIndex++, Property::BOOLEAN, NULL, &GetProperty );
- tet_result( TET_PASS );
+ PropertyRegistration property1(customType1, "propName", propertyIndex++, Property::BOOLEAN, NULL, &GetProperty);
+ tet_result(TET_PASS);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
}
// Attempt to register a property without a getter
try
{
- PropertyRegistration property1( customType1, "propName", propertyIndex++, Property::BOOLEAN, NULL, NULL );
- tet_result( TET_FAIL );
+ PropertyRegistration property1(customType1, "propName", propertyIndex++, Property::BOOLEAN, NULL, NULL);
+ tet_result(TET_FAIL);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "! \"GetProperty", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "! \"GetProperty", TEST_LOCATION);
}
END_TEST;
}
int UtcDaliPropertyRegistrationAddSameIndex(void)
{
TestApplication application;
- int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 100;
+ int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 100;
// Add one property with a valid property index
- PropertyRegistration property1( customType1, "propName", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property1(customType1, "propName", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty);
// Attempt to add another property with the same index
try
{
- PropertyRegistration property2( customType1, "propName2", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property2(customType1, "propName2", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "! \"Property index already added", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "! \"Property index already added", TEST_LOCATION);
}
int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 100;
// Add one property with a valid property index
- AnimatablePropertyRegistration property3( customType1, "animPropName", animatablePropertyIndex, Property::BOOLEAN );
+ AnimatablePropertyRegistration property3(customType1, "animPropName", animatablePropertyIndex, Property::BOOLEAN);
// Attempt to add another property with the same index
try
{
- AnimatablePropertyRegistration property4( customType1, "animPropName2", animatablePropertyIndex, Property::BOOLEAN );
+ AnimatablePropertyRegistration property4(customType1, "animPropName2", animatablePropertyIndex, Property::BOOLEAN);
}
- catch ( DaliException& e )
+ catch(DaliException& e)
{
- DALI_TEST_ASSERT( e, "! \"Property index already added", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "! \"Property index already added", TEST_LOCATION);
}
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyWritableP(void)
{
TestApplication application;
- int propertyIndex1 = PROPERTY_REGISTRATION_START_INDEX + 200;
- int propertyIndex2 = PROPERTY_REGISTRATION_START_INDEX + 201;
+ int propertyIndex1 = PROPERTY_REGISTRATION_START_INDEX + 200;
+ int propertyIndex2 = PROPERTY_REGISTRATION_START_INDEX + 201;
// Add two properties, one with SetProperty, one without
- PropertyRegistration property1( customType1, "propNameReadwrite", propertyIndex1, Property::BOOLEAN, &SetProperty, &GetProperty );
- PropertyRegistration property2( customType1, "propNameReadonly", propertyIndex2, Property::BOOLEAN, NULL, &GetProperty );
+ PropertyRegistration property1(customType1, "propNameReadwrite", propertyIndex1, Property::BOOLEAN, &SetProperty, &GetProperty);
+ PropertyRegistration property2(customType1, "propNameReadonly", propertyIndex2, Property::BOOLEAN, NULL, &GetProperty);
// Create custom-actor
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
// Check whether properties are writable
- DALI_TEST_CHECK( customActor.IsPropertyWritable( propertyIndex1 ) );
- DALI_TEST_CHECK( ! customActor.IsPropertyWritable( propertyIndex2 ) );
-
+ DALI_TEST_CHECK(customActor.IsPropertyWritable(propertyIndex1));
+ DALI_TEST_CHECK(!customActor.IsPropertyWritable(propertyIndex2));
// Check the property is writable in the type registry
- Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
+ Internal::TypeInfo& typeInfoImpl = GetImplementation(typeInfo);
- DALI_TEST_EQUALS( typeInfoImpl.IsPropertyWritable( propertyIndex1 ), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(typeInfoImpl.IsPropertyWritable(propertyIndex1), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyWritableN(void)
{
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
- Internal::TypeInfo& typeInfoImpl = GetImplementation( typeInfo );
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo(typeid(MyTestCustomActor));
+ Internal::TypeInfo& typeInfoImpl = GetImplementation(typeInfo);
- DALI_TEST_EQUALS( typeInfoImpl.IsPropertyWritable( Actor::Property::COLOR), true, TEST_LOCATION );
+ DALI_TEST_EQUALS(typeInfoImpl.IsPropertyWritable(Actor::Property::COLOR), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyAnimatable(void)
{
TestApplication application;
- int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 400;
- int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 400;
+ int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 400;
+ int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 400;
// These properties are not animatable
- PropertyRegistration property1( customType1, "propName", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty );
+ PropertyRegistration property1(customType1, "propName", propertyIndex, Property::BOOLEAN, &SetProperty, &GetProperty);
// These properties are animatable
- AnimatablePropertyRegistration property2( customType1, "animPropName", animatablePropertyIndex, Property::BOOLEAN );
+ AnimatablePropertyRegistration property2(customType1, "animPropName", animatablePropertyIndex, Property::BOOLEAN);
// Create custom-actor
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
// Check if animatable
- DALI_TEST_CHECK( ! customActor.IsPropertyAnimatable( propertyIndex ) );
- DALI_TEST_CHECK( customActor.IsPropertyAnimatable( animatablePropertyIndex ) );
+ DALI_TEST_CHECK(!customActor.IsPropertyAnimatable(propertyIndex));
+ DALI_TEST_CHECK(customActor.IsPropertyAnimatable(animatablePropertyIndex));
// Create another instance of custom-actor
BaseHandle handle2 = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle2 );
- Actor customActor2 = Actor::DownCast( handle2 );
- DALI_TEST_CHECK( customActor2 );
+ DALI_TEST_CHECK(handle2);
+ Actor customActor2 = Actor::DownCast(handle2);
+ DALI_TEST_CHECK(customActor2);
// Check if animatable
- DALI_TEST_CHECK( ! customActor2.IsPropertyAnimatable( propertyIndex ) );
- DALI_TEST_CHECK( customActor2.IsPropertyAnimatable( animatablePropertyIndex ) );
+ DALI_TEST_CHECK(!customActor2.IsPropertyAnimatable(propertyIndex));
+ DALI_TEST_CHECK(customActor2.IsPropertyAnimatable(animatablePropertyIndex));
END_TEST;
}
int UtcDaliPropertyRegistrationUnregisteredGetAndSet(void)
{
TestApplication application;
- int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 2000;
- int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2000;
+ int propertyIndex = PROPERTY_REGISTRATION_START_INDEX + 2000;
+ int animatablePropertyIndex = ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX + 2000;
// Create custom-actor
- TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
// Try to set an index that hasn't been registered, this is a no-op for now, to be fixed in future
- customActor.SetProperty( propertyIndex, true );
-// DALI_TEST_EQUALS( true, customActor.GetProperty( propertyIndex ).Get<bool>(), TEST_LOCATION);
+ customActor.SetProperty(propertyIndex, true);
+ // DALI_TEST_EQUALS( true, customActor.GetProperty( propertyIndex ).Get<bool>(), TEST_LOCATION);
// Try to set an index that hasn't been registered
- customActor.SetProperty( animatablePropertyIndex, true );
- DALI_TEST_EQUALS( true, customActor.GetProperty( animatablePropertyIndex ).Get<bool>(), TEST_LOCATION);
+ customActor.SetProperty(animatablePropertyIndex, true);
+ DALI_TEST_EQUALS(true, customActor.GetProperty(animatablePropertyIndex).Get<bool>(), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliLongPressGestureDetectorTypeRegistry(void)
{
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "LongPressGestureDetector" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("LongPressGestureDetector");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
- LongPressGestureDetector detector = LongPressGestureDetector::DownCast( handle );
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(handle);
+ LongPressGestureDetector detector = LongPressGestureDetector::DownCast(handle);
+ DALI_TEST_CHECK(detector);
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "longPressDetected", functor );
+ handle.ConnectSignal(&application, "longPressDetected", functor);
// Render and notify
application.SendNotification();
application.Render();
// Emit gesture
- TestGenerateLongPress( application, 50.0f, 10.0f );
- TestEndLongPress( application, 50.0f, 10.0f );
+ TestGenerateLongPress(application, 50.0f, 10.0f);
+ TestEndLongPress(application, 50.0f, 10.0f);
DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "PanGestureDetector" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("PanGestureDetector");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
- PanGestureDetector detector = PanGestureDetector::DownCast( handle );
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(handle);
+ PanGestureDetector detector = PanGestureDetector::DownCast(handle);
+ DALI_TEST_CHECK(detector);
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "panDetected", functor );
+ handle.ConnectSignal(&application, "panDetected", functor);
// Render and notify
application.SendNotification();
application.Render();
// Emit gesture
- TestGenerateMiniPan( application );
+ TestGenerateMiniPan(application);
DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "PinchGestureDetector" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("PinchGestureDetector");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
- PinchGestureDetector detector = PinchGestureDetector::DownCast( handle );
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(handle);
+ PinchGestureDetector detector = PinchGestureDetector::DownCast(handle);
+ DALI_TEST_CHECK(detector);
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "pinchDetected", functor );
+ handle.ConnectSignal(&application, "pinchDetected", functor);
// Render and notify
application.SendNotification();
application.Render();
// Emit gesture
- TestGeneratePinch( application );
+ TestGeneratePinch(application);
DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "RotationGestureDetector" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("RotationGestureDetector");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
- RotationGestureDetector detector = RotationGestureDetector::DownCast( handle );
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(handle);
+ RotationGestureDetector detector = RotationGestureDetector::DownCast(handle);
+ DALI_TEST_CHECK(detector);
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "rotationDetected", functor );
+ handle.ConnectSignal(&application, "rotationDetected", functor);
// Render and notify
application.SendNotification();
application.Render();
// Emit gesture
- TestGenerateRotation( application );
+ TestGenerateRotation(application);
DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
END_TEST;
TestApplication application;
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Register Type
TypeInfo type;
- type = TypeRegistry::Get().GetTypeInfo( "TapGestureDetector" );
- DALI_TEST_CHECK( type );
+ type = TypeRegistry::Get().GetTypeInfo("TapGestureDetector");
+ DALI_TEST_CHECK(type);
BaseHandle handle = type.CreateInstance();
- DALI_TEST_CHECK( handle );
- TapGestureDetector detector = TapGestureDetector::DownCast( handle );
- DALI_TEST_CHECK( detector );
+ DALI_TEST_CHECK(handle);
+ TapGestureDetector detector = TapGestureDetector::DownCast(handle);
+ DALI_TEST_CHECK(detector);
// Attach actor to detector
- SignalData data;
- GestureReceivedFunctor functor( data );
+ SignalData data;
+ GestureReceivedFunctor functor(data);
detector.Attach(actor);
// Connect to signal through type
- handle.ConnectSignal( &application, "tapDetected", functor );
+ handle.ConnectSignal(&application, "tapDetected", functor);
// Render and notify
application.SendNotification();
application.Render();
// Emit gesture
- TestGenerateTap( application, 50.0, 10.0, 100 );
+ TestGenerateTap(application, 50.0, 10.0, 100);
DALI_TEST_EQUALS(true, data.voidFunctorCalled, TEST_LOCATION);
END_TEST;
int UtcDaliTypeRegistryNamedType(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
// Create a normal actor
- BaseHandle actorHandle = typeRegistry.GetTypeInfo( "Actor" ).CreateInstance();
- DALI_TEST_CHECK( actorHandle );
- Actor actor( Actor::DownCast( actorHandle ) );
- DALI_TEST_CHECK( actor );
- unsigned int actorPropertyCount( actor.GetPropertyCount() );
+ BaseHandle actorHandle = typeRegistry.GetTypeInfo("Actor").CreateInstance();
+ DALI_TEST_CHECK(actorHandle);
+ Actor actor(Actor::DownCast(actorHandle));
+ DALI_TEST_CHECK(actor);
+ unsigned int actorPropertyCount(actor.GetPropertyCount());
// Create Named Actor Type
- BaseHandle namedHandle = typeRegistry.GetTypeInfo( "MyNamedActor" ).CreateInstance();
- DALI_TEST_CHECK( namedHandle );
- Actor namedActor( Actor::DownCast( namedHandle ) );
- DALI_TEST_CHECK( namedActor );
- unsigned int namedActorPropertyCount( namedActor.GetPropertyCount() );
+ BaseHandle namedHandle = typeRegistry.GetTypeInfo("MyNamedActor").CreateInstance();
+ DALI_TEST_CHECK(namedHandle);
+ Actor namedActor(Actor::DownCast(namedHandle));
+ DALI_TEST_CHECK(namedActor);
+ unsigned int namedActorPropertyCount(namedActor.GetPropertyCount());
- DALI_TEST_CHECK( namedActorPropertyCount > actorPropertyCount );
+ DALI_TEST_CHECK(namedActorPropertyCount > actorPropertyCount);
END_TEST;
}
int UtcDaliTypeInfoGetActionNameP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
- DALI_TEST_CHECK( 0 != typeInfo.GetActionCount() );
+ DALI_TEST_CHECK(0 != typeInfo.GetActionCount());
std::string name = typeInfo.GetActionName(0);
- DALI_TEST_EQUALS( name, "show", TEST_LOCATION );
+ DALI_TEST_EQUALS(name, "show", TEST_LOCATION);
-
- TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyTestCustomActor" );
+ TypeInfo typeInfo2 = typeRegistry.GetTypeInfo("MyTestCustomActor");
// search for show action in base class, given a derived class
bool foundChildAction = false;
- for( std::size_t i = 0; i < typeInfo2.GetActionCount(); i++ )
+ for(std::size_t i = 0; i < typeInfo2.GetActionCount(); i++)
{
-
- std::string name = typeInfo2.GetActionName( i );
- if( name == "show")
- {
- foundChildAction = true;
- }
-
+ std::string name = typeInfo2.GetActionName(i);
+ if(name == "show")
+ {
+ foundChildAction = true;
+ }
}
- DALI_TEST_EQUALS( foundChildAction, true, TEST_LOCATION );
-
+ DALI_TEST_EQUALS(foundChildAction, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeInfoGetActionNameN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
- DALI_TEST_CHECK( 0 != typeInfo.GetActionCount() );
+ DALI_TEST_CHECK(0 != typeInfo.GetActionCount());
std::string name = typeInfo.GetActionName(std::numeric_limits<size_t>::max());
- DALI_TEST_EQUALS( 0u, name.size(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, name.size(), TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeInfoGetSignalNameP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
- DALI_TEST_CHECK( 0 != typeInfo.GetSignalCount() );
+ DALI_TEST_CHECK(0 != typeInfo.GetSignalCount());
std::string name = typeInfo.GetSignalName(0);
- DALI_TEST_EQUALS( name, "hovered", TEST_LOCATION );
+ DALI_TEST_EQUALS(name, "hovered", TEST_LOCATION);
- TypeInfo typeInfo2 = typeRegistry.GetTypeInfo( "MyTestCustomActor" );
+ TypeInfo typeInfo2 = typeRegistry.GetTypeInfo("MyTestCustomActor");
// search for signal in base class, given a derived class
bool foundSignal = false;
- for( std::size_t i = 0; i < typeInfo2.GetSignalCount(); i++ )
+ for(std::size_t i = 0; i < typeInfo2.GetSignalCount(); i++)
{
- std::string name = typeInfo2.GetSignalName( i );
- if( name == "hovered")
+ std::string name = typeInfo2.GetSignalName(i);
+ if(name == "hovered")
{
foundSignal = true;
}
}
- DALI_TEST_EQUALS( foundSignal, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(foundSignal, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeInfoGetSignalNameN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
- DALI_TEST_CHECK( 0 != typeInfo.GetSignalCount() );
+ DALI_TEST_CHECK(0 != typeInfo.GetSignalCount());
std::string name = typeInfo.GetSignalName(std::numeric_limits<size_t>::max());
- DALI_TEST_EQUALS( 0u, name.size(), TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, name.size(), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliTypeInfoGetCreatorP(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
TypeInfo::CreateFunction createFn = typeInfo.GetCreator();
- DALI_TEST_EQUALS( createFn != NULL, true, TEST_LOCATION );
- if( createFn )
+ DALI_TEST_EQUALS(createFn != NULL, true, TEST_LOCATION);
+ if(createFn)
{
// try calling it:
BaseHandle handle = createFn();
- DALI_TEST_EQUALS( (bool)handle, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)handle, true, TEST_LOCATION);
}
END_TEST;
int UtcDaliTypeInfoGetCreatorN(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "MyTestCustomActor3" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("MyTestCustomActor3");
+ DALI_TEST_CHECK(typeInfo);
TypeInfo::CreateFunction createFn = typeInfo.GetCreator();
- DALI_TEST_EQUALS( createFn == NULL, true, TEST_LOCATION );
+ DALI_TEST_EQUALS(createFn == NULL, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeInfoGetPropertyCountP1(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "Actor" );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("Actor");
+ DALI_TEST_CHECK(typeInfo);
size_t actorPropertyCount = typeInfo.GetPropertyCount();
- DALI_TEST_EQUALS( actorPropertyCount, Actor::New().GetPropertyCount(), TEST_LOCATION ); // No event only props
+ DALI_TEST_EQUALS(actorPropertyCount, Actor::New().GetPropertyCount(), TEST_LOCATION); // No event only props
END_TEST;
}
int UtcDaliTypeInfoGetPropertyCountP2(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( "MyTestCustomActor2" );
- DALI_TEST_CHECK( typeInfo );
- size_t propertyCount = typeInfo.GetPropertyCount();
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo("MyTestCustomActor2");
+ DALI_TEST_CHECK(typeInfo);
+ size_t propertyCount = typeInfo.GetPropertyCount();
Property::IndexContainer indices;
- typeInfo.GetPropertyIndices( indices );
+ typeInfo.GetPropertyIndices(indices);
- DALI_TEST_EQUALS( propertyCount > 0 && propertyCount <= indices.Size(), true, TEST_LOCATION );
- DALI_TEST_EQUALS( propertyCount, Actor::New().GetPropertyCount() + 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(propertyCount > 0 && propertyCount <= indices.Size(), true, TEST_LOCATION);
+ DALI_TEST_EQUALS(propertyCount, Actor::New().GetPropertyCount() + 2, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGet01(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- tet_infoline( "Register a type registered animatable property and ensure set/get behaviour works synchronously" );
+ tet_infoline("Register a type registered animatable property and ensure set/get behaviour works synchronously");
// Register animatable property
- const int animatablePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- AnimatablePropertyRegistration animatableProperty( customType1, "animatableProp1", animatablePropertyIndex, Property::FLOAT );
+ const int animatablePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ AnimatablePropertyRegistration animatableProperty(customType1, "animatableProp1", animatablePropertyIndex, Property::FLOAT);
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
application.GetScene().Add(customActor);
- tet_infoline( "Set the value and ensure it changes straight away" );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 0.0f, TEST_LOCATION );
- customActor.SetProperty( animatablePropertyIndex, 25.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
+ tet_infoline("Set the value and ensure it changes straight away");
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 0.0f, TEST_LOCATION);
+ customActor.SetProperty(animatablePropertyIndex, 25.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 25.0f, TEST_LOCATION);
- tet_infoline( "Check latest scene-graph value is unchanged" );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 0.0f, TEST_LOCATION );
+ tet_infoline("Check latest scene-graph value is unchanged");
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyIndex), 0.0f, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
- tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
+ tet_infoline("Check values after rendering and both retrieval methods should return the latest");
- DALI_TEST_EQUALS( customActor.GetProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( animatablePropertyIndex ), 25.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(animatablePropertyIndex), 25.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(animatablePropertyIndex), 25.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector2(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- tet_infoline( "Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set" );
+ tet_infoline("Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set");
// Register the animatable propeties
- const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- const int componentZeroPropertyIndex( basePropertyIndex + 1 );
- const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
- AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector2( 13.0f, 24.0f ) );
- AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
- AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
+ const int basePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ const int componentZeroPropertyIndex(basePropertyIndex + 1);
+ const int componentOnePropertyIndex(componentZeroPropertyIndex + 1);
+ AnimatablePropertyRegistration baseAnimatableProperty(customType1, "baseProp", basePropertyIndex, Vector2(13.0f, 24.0f));
+ AnimatablePropertyComponentRegistration componentZeroAnimatableProperty(customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0);
+ AnimatablePropertyComponentRegistration componentOneAnimatableProperty(customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1);
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
application.GetScene().Add(customActor);
- tet_infoline( "Get the component values, they should be the default value of the base-property" );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 13.0f, 24.0f ), TEST_LOCATION );
+ tet_infoline("Get the component values, they should be the default value of the base-property");
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 13.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 24.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(basePropertyIndex), Vector2(13.0f, 24.0f), TEST_LOCATION);
- tet_infoline( "Set a component value and ensure it changes for the base property as well" );
- customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 24.0f ), TEST_LOCATION );
+ tet_infoline("Set a component value and ensure it changes for the base property as well");
+ customActor.SetProperty(componentZeroPropertyIndex, 125.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(basePropertyIndex), Vector2(125.0f, 24.0f), TEST_LOCATION);
- customActor.SetProperty( componentOnePropertyIndex, 225.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
+ customActor.SetProperty(componentOnePropertyIndex, 225.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(basePropertyIndex), Vector2(125.0f, 225.0f), TEST_LOCATION);
- tet_infoline( "Check latest scene-graph value is unchanged" );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( basePropertyIndex ), Vector2( 13.0f, 24.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
+ tet_infoline("Check latest scene-graph value is unchanged");
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector2>(basePropertyIndex), Vector2(13.0f, 24.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentZeroPropertyIndex), 13.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentOnePropertyIndex), 24.0f, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
- tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
+ tet_infoline("Check values after rendering and both retrieval methods should return the latest");
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(basePropertyIndex), Vector2(125.0f, 225.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector2 >( basePropertyIndex ), Vector2( 125.0f, 225.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector2>(basePropertyIndex), Vector2(125.0f, 225.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
- tet_infoline( "Set the base property value and ensure the component values reflect the change" );
- customActor.SetProperty( basePropertyIndex, Vector2( 1.0f, 2.0f ) );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector2 >( basePropertyIndex ), Vector2( 1.0f, 2.0f ), TEST_LOCATION );
+ tet_infoline("Set the base property value and ensure the component values reflect the change");
+ customActor.SetProperty(basePropertyIndex, Vector2(1.0f, 2.0f));
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector2>(basePropertyIndex), Vector2(1.0f, 2.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector3(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- tet_infoline( "Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set" );
+ tet_infoline("Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set");
// Register the animatable propeties
- const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- const int componentZeroPropertyIndex( basePropertyIndex + 1 );
- const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
- const int componentTwoPropertyIndex( componentOnePropertyIndex + 1 );
- AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector3( 13.0f, 24.0f, 35.0 ) );
- AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
- AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
- AnimatablePropertyComponentRegistration componentTwoAnimatableProperty( customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2 );
+ const int basePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ const int componentZeroPropertyIndex(basePropertyIndex + 1);
+ const int componentOnePropertyIndex(componentZeroPropertyIndex + 1);
+ const int componentTwoPropertyIndex(componentOnePropertyIndex + 1);
+ AnimatablePropertyRegistration baseAnimatableProperty(customType1, "baseProp", basePropertyIndex, Vector3(13.0f, 24.0f, 35.0));
+ AnimatablePropertyComponentRegistration componentZeroAnimatableProperty(customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0);
+ AnimatablePropertyComponentRegistration componentOneAnimatableProperty(customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1);
+ AnimatablePropertyComponentRegistration componentTwoAnimatableProperty(customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2);
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
application.GetScene().Add(customActor);
- tet_infoline( "Get the component values, they should be the default value of the base-property" );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 13.0f, 24.0f, 35.0f ), TEST_LOCATION );
+ tet_infoline("Get the component values, they should be the default value of the base-property");
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 13.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 24.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 35.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(basePropertyIndex), Vector3(13.0f, 24.0f, 35.0f), TEST_LOCATION);
- tet_infoline( "Set a component value and ensure it changes for the base property as well" );
- customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 24.0f, 35.0f ), TEST_LOCATION );
+ tet_infoline("Set a component value and ensure it changes for the base property as well");
+ customActor.SetProperty(componentZeroPropertyIndex, 125.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(basePropertyIndex), Vector3(125.0f, 24.0f, 35.0f), TEST_LOCATION);
- customActor.SetProperty( componentOnePropertyIndex, 225.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 35.0f ), TEST_LOCATION );
+ customActor.SetProperty(componentOnePropertyIndex, 225.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(basePropertyIndex), Vector3(125.0f, 225.0f, 35.0f), TEST_LOCATION);
- customActor.SetProperty( componentTwoPropertyIndex, 325.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
+ customActor.SetProperty(componentTwoPropertyIndex, 325.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 325.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(basePropertyIndex), Vector3(125.0f, 225.0f, 325.0f), TEST_LOCATION);
- tet_infoline( "Check latest scene-graph value is unchanged" );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( basePropertyIndex ), Vector3( 13.0f, 24.0f, 35.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
+ tet_infoline("Check latest scene-graph value is unchanged");
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector3>(basePropertyIndex), Vector3(13.0f, 24.0f, 35.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentZeroPropertyIndex), 13.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentOnePropertyIndex), 24.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentTwoPropertyIndex), 35.0f, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
- tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
+ tet_infoline("Check values after rendering and both retrieval methods should return the latest");
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(basePropertyIndex), Vector3(125.0f, 225.0f, 325.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 325.0f, TEST_LOCATION);
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector3 >( basePropertyIndex ), Vector3( 125.0f, 225.0f, 325.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector3>(basePropertyIndex), Vector3(125.0f, 225.0f, 325.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentTwoPropertyIndex), 325.0f, TEST_LOCATION);
- tet_infoline( "Set the base property value and ensure the component values reflect the change" );
- customActor.SetProperty( basePropertyIndex, Vector3( 1.0f, 2.0f, 3.0f ) );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 3.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector3 >( basePropertyIndex ), Vector3( 1.0f, 2.0f, 3.0f ), TEST_LOCATION );
+ tet_infoline("Set the base property value and ensure the component values reflect the change");
+ customActor.SetProperty(basePropertyIndex, Vector3(1.0f, 2.0f, 3.0f));
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 3.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector3>(basePropertyIndex), Vector3(1.0f, 2.0f, 3.0f), TEST_LOCATION);
END_TEST;
}
int UtcDaliPropertyRegistrationPropertyAnimatableSynchronousSetGetWithComponentsVector4(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- tet_infoline( "Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set" );
+ tet_infoline("Register a type registered animatable property that has component indices and ensure set/get behaviour works synchronously and is the same regardless of how the property is set");
// Register the animatable propeties
- const int basePropertyIndex( ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX );
- const int componentZeroPropertyIndex( basePropertyIndex + 1 );
- const int componentOnePropertyIndex( componentZeroPropertyIndex + 1 );
- const int componentTwoPropertyIndex( componentOnePropertyIndex + 1 );
- const int componentThreePropertyIndex( componentTwoPropertyIndex + 1 );
- AnimatablePropertyRegistration baseAnimatableProperty( customType1, "baseProp", basePropertyIndex, Vector4( 13.0f, 24.0f, 35.0, 47.0f ) );
- AnimatablePropertyComponentRegistration componentZeroAnimatableProperty( customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0 );
- AnimatablePropertyComponentRegistration componentOneAnimatableProperty( customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1 );
- AnimatablePropertyComponentRegistration componentTwoAnimatableProperty( customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2 );
- AnimatablePropertyComponentRegistration componentThreeAnimatableProperty( customType1, "componentThreeProp", componentThreePropertyIndex, basePropertyIndex, 3 );
+ const int basePropertyIndex(ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX);
+ const int componentZeroPropertyIndex(basePropertyIndex + 1);
+ const int componentOnePropertyIndex(componentZeroPropertyIndex + 1);
+ const int componentTwoPropertyIndex(componentOnePropertyIndex + 1);
+ const int componentThreePropertyIndex(componentTwoPropertyIndex + 1);
+ AnimatablePropertyRegistration baseAnimatableProperty(customType1, "baseProp", basePropertyIndex, Vector4(13.0f, 24.0f, 35.0, 47.0f));
+ AnimatablePropertyComponentRegistration componentZeroAnimatableProperty(customType1, "componentZeroProp", componentZeroPropertyIndex, basePropertyIndex, 0);
+ AnimatablePropertyComponentRegistration componentOneAnimatableProperty(customType1, "componentOneProp", componentOnePropertyIndex, basePropertyIndex, 1);
+ AnimatablePropertyComponentRegistration componentTwoAnimatableProperty(customType1, "componentTwoProp", componentTwoPropertyIndex, basePropertyIndex, 2);
+ AnimatablePropertyComponentRegistration componentThreeAnimatableProperty(customType1, "componentThreeProp", componentThreePropertyIndex, basePropertyIndex, 3);
// Check property count before property registration
- TypeInfo typeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( typeInfo );
+ TypeInfo typeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(typeInfo);
BaseHandle handle = typeInfo.CreateInstance();
- DALI_TEST_CHECK( handle );
- Actor customActor = Actor::DownCast( handle );
- DALI_TEST_CHECK( customActor );
+ DALI_TEST_CHECK(handle);
+ Actor customActor = Actor::DownCast(handle);
+ DALI_TEST_CHECK(customActor);
application.GetScene().Add(customActor);
- tet_infoline( "Get the component values, they should be the default value of the base-property" );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 47.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 13.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
-
- tet_infoline( "Set a component value and ensure it changes for the base property as well" );
- customActor.SetProperty( componentZeroPropertyIndex, 125.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
-
- customActor.SetProperty( componentOnePropertyIndex, 225.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 35.0f, 47.0f ), TEST_LOCATION );
-
- customActor.SetProperty( componentTwoPropertyIndex, 325.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 47.0f ), TEST_LOCATION );
-
- customActor.SetProperty( componentThreePropertyIndex, 435.0f );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
-
- tet_infoline( "Check latest scene-graph value is unchanged" );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( basePropertyIndex ), Vector4( 13.0f, 24.0f, 35.0f, 47.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 13.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 24.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 35.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentThreePropertyIndex ), 47.0f, TEST_LOCATION );
+ tet_infoline("Get the component values, they should be the default value of the base-property");
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 13.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 24.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 35.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentThreePropertyIndex), 47.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(13.0f, 24.0f, 35.0f, 47.0f), TEST_LOCATION);
+
+ tet_infoline("Set a component value and ensure it changes for the base property as well");
+ customActor.SetProperty(componentZeroPropertyIndex, 125.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(125.0f, 24.0f, 35.0f, 47.0f), TEST_LOCATION);
+
+ customActor.SetProperty(componentOnePropertyIndex, 225.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(125.0f, 225.0f, 35.0f, 47.0f), TEST_LOCATION);
+
+ customActor.SetProperty(componentTwoPropertyIndex, 325.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 325.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(125.0f, 225.0f, 325.0f, 47.0f), TEST_LOCATION);
+
+ customActor.SetProperty(componentThreePropertyIndex, 435.0f);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentThreePropertyIndex), 435.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(125.0f, 225.0f, 325.0f, 435.0f), TEST_LOCATION);
+
+ tet_infoline("Check latest scene-graph value is unchanged");
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector4>(basePropertyIndex), Vector4(13.0f, 24.0f, 35.0f, 47.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentZeroPropertyIndex), 13.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentOnePropertyIndex), 24.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentTwoPropertyIndex), 35.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentThreePropertyIndex), 47.0f, TEST_LOCATION);
// Render and notify
application.SendNotification();
application.Render();
- tet_infoline( "Check values after rendering and both retrieval methods should return the latest" );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
+ tet_infoline("Check values after rendering and both retrieval methods should return the latest");
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(125.0f, 225.0f, 325.0f, 435.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 325.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentThreePropertyIndex), 435.0f, TEST_LOCATION);
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< Vector4 >( basePropertyIndex ), Vector4( 125.0f, 225.0f, 325.0f, 435.0f ), TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentZeroPropertyIndex ), 125.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentOnePropertyIndex ), 225.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentTwoPropertyIndex ), 325.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetCurrentProperty< float >( componentThreePropertyIndex ), 435.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<Vector4>(basePropertyIndex), Vector4(125.0f, 225.0f, 325.0f, 435.0f), TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentZeroPropertyIndex), 125.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentOnePropertyIndex), 225.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentTwoPropertyIndex), 325.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetCurrentProperty<float>(componentThreePropertyIndex), 435.0f, TEST_LOCATION);
- tet_infoline( "Set the base property value and ensure the component values reflect the change" );
- customActor.SetProperty( basePropertyIndex, Vector4( 1.0f, 2.0f, 3.0f, 4.0f ) );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentZeroPropertyIndex ), 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentOnePropertyIndex ), 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentTwoPropertyIndex ), 3.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< float >( componentThreePropertyIndex ), 4.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( customActor.GetProperty< Vector4 >( basePropertyIndex ), Vector4( 1.0f, 2.0f, 3.0f, 4.0f ), TEST_LOCATION );
+ tet_infoline("Set the base property value and ensure the component values reflect the change");
+ customActor.SetProperty(basePropertyIndex, Vector4(1.0f, 2.0f, 3.0f, 4.0f));
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentZeroPropertyIndex), 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentOnePropertyIndex), 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentTwoPropertyIndex), 3.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<float>(componentThreePropertyIndex), 4.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(customActor.GetProperty<Vector4>(basePropertyIndex), Vector4(1.0f, 2.0f, 3.0f, 4.0f), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliTypeInfoRegisterChildProperties01(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- tet_infoline( "Register child properties on a type via name" );
+ tet_infoline("Register child properties on a type via name");
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(CustomActor) );
- auto myCustomTypeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( customActorTypeInfo );
- DALI_TEST_CHECK( myCustomTypeInfo );
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(CustomActor));
+ auto myCustomTypeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(customActorTypeInfo);
+ DALI_TEST_CHECK(myCustomTypeInfo);
- const Property::Index WIDTH_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const Property::Index HEIGHT_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
- const Property::Index MARGIN_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX + 100);
+ const Property::Index WIDTH_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const Property::Index HEIGHT_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
+ const Property::Index MARGIN_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX + 100);
- ChildPropertyRegistration( customActorTypeInfo.GetName(), "widthSpecification", WIDTH_SPECIFICATION, Property::INTEGER );
- ChildPropertyRegistration( customActorTypeInfo.GetName(), "heightSpecification", HEIGHT_SPECIFICATION, Property::INTEGER );
- ChildPropertyRegistration( myCustomTypeInfo.GetName(), "marginSpecification", MARGIN_SPECIFICATION, Property::EXTENTS );
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), "widthSpecification", WIDTH_SPECIFICATION, Property::INTEGER);
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), "heightSpecification", HEIGHT_SPECIFICATION, Property::INTEGER);
+ ChildPropertyRegistration(myCustomTypeInfo.GetName(), "marginSpecification", MARGIN_SPECIFICATION, Property::EXTENTS);
auto customActor = MyTestCustomActor::New();
- application.GetScene().Add( customActor );
+ application.GetScene().Add(customActor);
auto child = Actor::New();
- customActor.Add( child );
+ customActor.Add(child);
- child.SetProperty( WIDTH_SPECIFICATION, 33 );
+ child.SetProperty(WIDTH_SPECIFICATION, 33);
- auto value = child.GetProperty( WIDTH_SPECIFICATION );
- DALI_TEST_EQUALS( value, Property::Value(33), TEST_LOCATION );
+ auto value = child.GetProperty(WIDTH_SPECIFICATION);
+ DALI_TEST_EQUALS(value, Property::Value(33), TEST_LOCATION);
- child.SetProperty( HEIGHT_SPECIFICATION, 44 );
- value = child.GetProperty( HEIGHT_SPECIFICATION );
- DALI_TEST_EQUALS( value, Property::Value(44), TEST_LOCATION );
+ child.SetProperty(HEIGHT_SPECIFICATION, 44);
+ value = child.GetProperty(HEIGHT_SPECIFICATION);
+ DALI_TEST_EQUALS(value, Property::Value(44), TEST_LOCATION);
- child.SetProperty( MARGIN_SPECIFICATION, Extents(10, 10, 10, 10) );
- value = child.GetProperty( MARGIN_SPECIFICATION );
- DALI_TEST_EQUALS( value, Property::Value(Extents(10,10,10,10)), TEST_LOCATION );
+ child.SetProperty(MARGIN_SPECIFICATION, Extents(10, 10, 10, 10));
+ value = child.GetProperty(MARGIN_SPECIFICATION);
+ DALI_TEST_EQUALS(value, Property::Value(Extents(10, 10, 10, 10)), TEST_LOCATION);
END_TEST;
}
-
int UtcDaliTypeInfoRegisterChildProperties02(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
-
- tet_infoline( "Register child properties on a type via name" );
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(CustomActor) );
- auto myCustomTypeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( customActorTypeInfo );
- DALI_TEST_CHECK( myCustomTypeInfo );
+ tet_infoline("Register child properties on a type via name");
- const Property::Index WIDTH_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const Property::Index HEIGHT_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
- const Property::Index MARGIN_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX + 100);
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(CustomActor));
+ auto myCustomTypeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(customActorTypeInfo);
+ DALI_TEST_CHECK(myCustomTypeInfo);
- ChildPropertyRegistration( customActorTypeInfo.GetName(), "widthSpecification", WIDTH_SPECIFICATION, Property::INTEGER );
- ChildPropertyRegistration( customActorTypeInfo.GetName(), "heightSpecification", HEIGHT_SPECIFICATION, Property::INTEGER );
- ChildPropertyRegistration( myCustomTypeInfo.GetName(), "marginSpecification", MARGIN_SPECIFICATION, Property::EXTENTS );
+ const Property::Index WIDTH_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const Property::Index HEIGHT_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
+ const Property::Index MARGIN_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX + 100);
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), "widthSpecification", WIDTH_SPECIFICATION, Property::INTEGER);
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), "heightSpecification", HEIGHT_SPECIFICATION, Property::INTEGER);
+ ChildPropertyRegistration(myCustomTypeInfo.GetName(), "marginSpecification", MARGIN_SPECIFICATION, Property::EXTENTS);
- auto index = customActorTypeInfo.GetChildPropertyIndex( "widthSpecification" );
- DALI_TEST_EQUALS( index, WIDTH_SPECIFICATION, TEST_LOCATION );
+ auto index = customActorTypeInfo.GetChildPropertyIndex("widthSpecification");
+ DALI_TEST_EQUALS(index, WIDTH_SPECIFICATION, TEST_LOCATION);
- index = customActorTypeInfo.GetChildPropertyIndex( "heightSpecification" );
- DALI_TEST_EQUALS( index, HEIGHT_SPECIFICATION, TEST_LOCATION );
+ index = customActorTypeInfo.GetChildPropertyIndex("heightSpecification");
+ DALI_TEST_EQUALS(index, HEIGHT_SPECIFICATION, TEST_LOCATION);
- index = customActorTypeInfo.GetChildPropertyIndex( "marginSpecification" );
- DALI_TEST_EQUALS( index, Property::INVALID_INDEX, TEST_LOCATION );
+ index = customActorTypeInfo.GetChildPropertyIndex("marginSpecification");
+ DALI_TEST_EQUALS(index, Property::INVALID_INDEX, TEST_LOCATION);
- index = myCustomTypeInfo.GetChildPropertyIndex( "marginSpecification" );
- DALI_TEST_EQUALS( index, MARGIN_SPECIFICATION, TEST_LOCATION );
+ index = myCustomTypeInfo.GetChildPropertyIndex("marginSpecification");
+ DALI_TEST_EQUALS(index, MARGIN_SPECIFICATION, TEST_LOCATION);
+ auto name = customActorTypeInfo.GetChildPropertyName(WIDTH_SPECIFICATION);
+ DALI_TEST_EQUALS(name, "widthSpecification", TEST_LOCATION);
- auto name = customActorTypeInfo.GetChildPropertyName( WIDTH_SPECIFICATION );
- DALI_TEST_EQUALS( name, "widthSpecification", TEST_LOCATION );
+ name = customActorTypeInfo.GetChildPropertyName(HEIGHT_SPECIFICATION);
+ DALI_TEST_EQUALS(name, "heightSpecification", TEST_LOCATION);
- name = customActorTypeInfo.GetChildPropertyName( HEIGHT_SPECIFICATION );
- DALI_TEST_EQUALS( name, "heightSpecification", TEST_LOCATION );
+ name = myCustomTypeInfo.GetChildPropertyName(MARGIN_SPECIFICATION);
+ DALI_TEST_EQUALS(name, "marginSpecification", TEST_LOCATION);
- name = myCustomTypeInfo.GetChildPropertyName( MARGIN_SPECIFICATION );
- DALI_TEST_EQUALS( name, "marginSpecification", TEST_LOCATION );
+ auto type = customActorTypeInfo.GetChildPropertyType(WIDTH_SPECIFICATION);
+ DALI_TEST_EQUALS(type, Property::INTEGER, TEST_LOCATION);
+ type = customActorTypeInfo.GetChildPropertyType(HEIGHT_SPECIFICATION);
+ DALI_TEST_EQUALS(type, Property::INTEGER, TEST_LOCATION);
- auto type = customActorTypeInfo.GetChildPropertyType( WIDTH_SPECIFICATION );
- DALI_TEST_EQUALS( type, Property::INTEGER, TEST_LOCATION );
-
- type = customActorTypeInfo.GetChildPropertyType( HEIGHT_SPECIFICATION );
- DALI_TEST_EQUALS( type, Property::INTEGER, TEST_LOCATION );
-
- type = myCustomTypeInfo.GetChildPropertyType( MARGIN_SPECIFICATION );
- DALI_TEST_EQUALS( type, Property::EXTENTS, TEST_LOCATION );
-
+ type = myCustomTypeInfo.GetChildPropertyType(MARGIN_SPECIFICATION);
+ DALI_TEST_EQUALS(type, Property::EXTENTS, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliTypeInfoRegisterChildProperties03(void)
{
TestApplication application;
- TypeRegistry typeRegistry = TypeRegistry::Get();
+ TypeRegistry typeRegistry = TypeRegistry::Get();
- tet_infoline( "Check registered child properties can be retrieved" );
+ tet_infoline("Check registered child properties can be retrieved");
- auto customActorTypeInfo = typeRegistry.GetTypeInfo( typeid(CustomActor) );
- auto myCustomTypeInfo = typeRegistry.GetTypeInfo( typeid(MyTestCustomActor) );
- DALI_TEST_CHECK( customActorTypeInfo );
- DALI_TEST_CHECK( myCustomTypeInfo );
+ auto customActorTypeInfo = typeRegistry.GetTypeInfo(typeid(CustomActor));
+ auto myCustomTypeInfo = typeRegistry.GetTypeInfo(typeid(MyTestCustomActor));
+ DALI_TEST_CHECK(customActorTypeInfo);
+ DALI_TEST_CHECK(myCustomTypeInfo);
- const Property::Index WIDTH_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX );
- const Property::Index HEIGHT_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
- const Property::Index MARGIN_SPECIFICATION( CHILD_PROPERTY_REGISTRATION_START_INDEX + 100);
+ const Property::Index WIDTH_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX);
+ const Property::Index HEIGHT_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX + 1);
+ const Property::Index MARGIN_SPECIFICATION(CHILD_PROPERTY_REGISTRATION_START_INDEX + 100);
- ChildPropertyRegistration( customActorTypeInfo.GetName(), "widthSpecification", WIDTH_SPECIFICATION, Property::INTEGER );
- ChildPropertyRegistration( customActorTypeInfo.GetName(), "heightSpecification", HEIGHT_SPECIFICATION, Property::INTEGER );
- ChildPropertyRegistration( myCustomTypeInfo.GetName(), "marginSpecification", MARGIN_SPECIFICATION, Property::EXTENTS );
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), "widthSpecification", WIDTH_SPECIFICATION, Property::INTEGER);
+ ChildPropertyRegistration(customActorTypeInfo.GetName(), "heightSpecification", HEIGHT_SPECIFICATION, Property::INTEGER);
+ ChildPropertyRegistration(myCustomTypeInfo.GetName(), "marginSpecification", MARGIN_SPECIFICATION, Property::EXTENTS);
Property::IndexContainer indices;
- myCustomTypeInfo.GetChildPropertyIndices( indices );
+ myCustomTypeInfo.GetChildPropertyIndices(indices);
- auto result = std::find( indices.Begin(), indices.End(), WIDTH_SPECIFICATION );
- DALI_TEST_EQUALS( result != indices.End(), true, TEST_LOCATION );
+ auto result = std::find(indices.Begin(), indices.End(), WIDTH_SPECIFICATION);
+ DALI_TEST_EQUALS(result != indices.End(), true, TEST_LOCATION);
- result = std::find( indices.Begin(), indices.End(), HEIGHT_SPECIFICATION );
- DALI_TEST_EQUALS( result != indices.End(), true, TEST_LOCATION );
+ result = std::find(indices.Begin(), indices.End(), HEIGHT_SPECIFICATION);
+ DALI_TEST_EQUALS(result != indices.End(), true, TEST_LOCATION);
- result = std::find( indices.Begin(), indices.End(), MARGIN_SPECIFICATION );
- DALI_TEST_EQUALS( result != indices.End(), true, TEST_LOCATION );
+ result = std::find(indices.Begin(), indices.End(), MARGIN_SPECIFICATION);
+ DALI_TEST_EQUALS(result != indices.End(), true, TEST_LOCATION);
END_TEST;
}
int UtcDaliTypeInfoGetActionNameNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
unsigned long arg1(0u);
int UtcDaliTypeInfoGetSignalNameNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
unsigned long arg1(0u);
int UtcDaliTypeInfoGetCreatorNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.GetCreator();
int UtcDaliTypeInfoGetBaseNameNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.GetBaseName();
int UtcDaliTypeInfoCreateInstanceNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.CreateInstance();
int UtcDaliTypeInfoGetActionCountNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.GetActionCount();
int UtcDaliTypeInfoGetSignalCountNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.GetSignalCount();
int UtcDaliTypeInfoGetPropertyNameNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
int arg1(0);
int UtcDaliTypeInfoGetPropertyCountNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.GetPropertyCount();
int UtcDaliTypeInfoGetPropertyIndicesNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
Dali::Vector<int> arg1;
int UtcDaliTypeInfoGetChildPropertyNameNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
int arg1(0);
int UtcDaliTypeInfoGetChildPropertyTypeNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
int arg1(0);
int UtcDaliTypeInfoGetChildPropertyIndexNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
std::string arg1;
int UtcDaliTypeInfoGetChildPropertyIndicesNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
Dali::Vector<int> arg1;
int UtcDaliTypeInfoGetNameNegative(void)
{
TestApplication application;
- Dali::TypeInfo instance;
+ Dali::TypeInfo instance;
try
{
instance.GetName();
int UtcDaliTypeRegistryGetTypeInfoNegative01(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TypeRegistry instance;
try
{
int UtcDaliTypeRegistryGetTypeInfoNegative02(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TypeRegistry instance;
try
{
int UtcDaliTypeRegistryGetTypeNameNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TypeRegistry instance;
try
{
int UtcDaliTypeRegistryGetTypeNameCountNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::TypeRegistry instance;
try
{
*
*/
-#include <iostream>
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
/// Compare a uint16_t value with an unsigned int
-void DALI_TEST_EQUALS( uint16_t value1, unsigned int value2, const char* location )
+void DALI_TEST_EQUALS(uint16_t value1, unsigned int value2, const char* location)
{
- ::DALI_TEST_EQUALS< uint16_t >( value1, static_cast< uint16_t >( value2 ), location );
+ ::DALI_TEST_EQUALS<uint16_t>(value1, static_cast<uint16_t>(value2), location);
}
} // unnamed namespace
{
Uint16Pair v;
- DALI_TEST_EQUALS( v.GetX(), 0u, TEST_LOCATION );
- DALI_TEST_EQUALS( v.GetY(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS(v.GetX(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.GetY(), 0u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairConstructor02P(void)
{
- Uint16Pair v( 10u, 10u );
+ Uint16Pair v(10u, 10u);
- DALI_TEST_EQUALS( v.GetX(), 10u, TEST_LOCATION );
- DALI_TEST_EQUALS( v.GetY(), 10u, TEST_LOCATION );
+ DALI_TEST_EQUALS(v.GetX(), 10u, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.GetY(), 10u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairCopyConstructor(void)
{
- Uint16Pair u( 5u, 5u );
- Uint16Pair v( u );
- DALI_TEST_EQUALS( v.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( v.GetY(), 5u, TEST_LOCATION );
+ Uint16Pair u(5u, 5u);
+ Uint16Pair v(u);
+ DALI_TEST_EQUALS(v.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairMoveConstructor(void)
{
- Uint16Pair u( 5u, 5u );
- Uint16Pair v = std::move( u );
- DALI_TEST_EQUALS( v.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( v.GetY(), 5u, TEST_LOCATION );
+ Uint16Pair u(5u, 5u);
+ Uint16Pair v = std::move(u);
+ DALI_TEST_EQUALS(v.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairCopyAssignment(void)
{
- Uint16Pair u( 5u, 5u );
+ Uint16Pair u(5u, 5u);
Uint16Pair v;
v = u;
- DALI_TEST_EQUALS( v.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( v.GetY(), 5u, TEST_LOCATION );
+ DALI_TEST_EQUALS(v.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairMoveAssignment(void)
{
- Uint16Pair u( 5u, 5u );
+ Uint16Pair u(5u, 5u);
Uint16Pair v;
- v = std::move( u );
- DALI_TEST_EQUALS( v.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( v.GetY(), 5u, TEST_LOCATION );
+ v = std::move(u);
+ DALI_TEST_EQUALS(v.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairGetWidthP(void)
{
- Uint16Pair v( 5u ,5u );
- DALI_TEST_EQUALS( v.GetWidth(), 5u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetWidth(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairGetHeightP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetHeight(), 5u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetHeight(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairGetXP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetX(), 5u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetX(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairGetYP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetY(), 5u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairSetXP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetX(), 5u, TEST_LOCATION );
- v.SetX( 10u );
- DALI_TEST_EQUALS( v.GetX(), 10u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetX(), 5u, TEST_LOCATION);
+ v.SetX(10u);
+ DALI_TEST_EQUALS(v.GetX(), 10u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairSetWidthP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetWidth(), 5u, TEST_LOCATION );
- v.SetWidth( 10u );
- DALI_TEST_EQUALS( v.GetWidth(), 10u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetWidth(), 5u, TEST_LOCATION);
+ v.SetWidth(10u);
+ DALI_TEST_EQUALS(v.GetWidth(), 10u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairSetYP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetY(), 5u, TEST_LOCATION );
- v.SetY( 10u );
- DALI_TEST_EQUALS( v.GetY(), 10u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetY(), 5u, TEST_LOCATION);
+ v.SetY(10u);
+ DALI_TEST_EQUALS(v.GetY(), 10u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairSetHeightP(void)
{
- Uint16Pair v( 5u, 5u );
- DALI_TEST_EQUALS( v.GetHeight(), 5u, TEST_LOCATION );
- v.SetHeight( 10u );
- DALI_TEST_EQUALS( v.GetHeight(), 10u, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ DALI_TEST_EQUALS(v.GetHeight(), 5u, TEST_LOCATION);
+ v.SetHeight(10u);
+ DALI_TEST_EQUALS(v.GetHeight(), 10u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairEqualsP(void)
{
- Uint16Pair v( 5u, 5u );
- Uint16Pair u( 5u, 5u );
- DALI_TEST_EQUALS( v == u, true, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ Uint16Pair u(5u, 5u);
+ DALI_TEST_EQUALS(v == u, true, TEST_LOCATION);
- v = Uint16Pair( 5u, 4u );
- u = Uint16Pair( 5u, 5u );
- DALI_TEST_EQUALS( v == u, false, TEST_LOCATION );
+ v = Uint16Pair(5u, 4u);
+ u = Uint16Pair(5u, 5u);
+ DALI_TEST_EQUALS(v == u, false, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairNotEqualsP(void)
{
- Uint16Pair v( 5u, 5u );
- Uint16Pair u( 5u, 5u );
- DALI_TEST_EQUALS( v != u, false, TEST_LOCATION );
+ Uint16Pair v(5u, 5u);
+ Uint16Pair u(5u, 5u);
+ DALI_TEST_EQUALS(v != u, false, TEST_LOCATION);
- v = Uint16Pair( 5u, 4u );
- u = Uint16Pair( 5u, 5u );
- DALI_TEST_EQUALS( v != u, true, TEST_LOCATION );
+ v = Uint16Pair(5u, 4u);
+ u = Uint16Pair(5u, 5u);
+ DALI_TEST_EQUALS(v != u, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairLessThanP(void)
{
- Uint16Pair u( 5u, 5u );
- Uint16Pair v( 6u, 6u );
- DALI_TEST_EQUALS( u < v, true, TEST_LOCATION );
+ Uint16Pair u(5u, 5u);
+ Uint16Pair v(6u, 6u);
+ DALI_TEST_EQUALS(u < v, true, TEST_LOCATION);
- u = Uint16Pair( 0u, 1u );
- v = Uint16Pair( 1u, 0u );
- DALI_TEST_EQUALS( v < u, true, TEST_LOCATION );
+ u = Uint16Pair(0u, 1u);
+ v = Uint16Pair(1u, 0u);
+ DALI_TEST_EQUALS(v < u, true, TEST_LOCATION);
- u = Uint16Pair( 1u, 0u );
- v = Uint16Pair( 0u, 1u );
- DALI_TEST_EQUALS( v < u, false, TEST_LOCATION );
+ u = Uint16Pair(1u, 0u);
+ v = Uint16Pair(0u, 1u);
+ DALI_TEST_EQUALS(v < u, false, TEST_LOCATION);
END_TEST;
}
Uint16Pair u;
Uint16Pair v;
- u = Uint16Pair( 0u, 1u );
- v = Uint16Pair( 1u, 0u );
- DALI_TEST_EQUALS( u > v, true, TEST_LOCATION );
+ u = Uint16Pair(0u, 1u);
+ v = Uint16Pair(1u, 0u);
+ DALI_TEST_EQUALS(u > v, true, TEST_LOCATION);
- u = Uint16Pair( 1u, 0u );
- v = Uint16Pair( 0u, 1u );
- DALI_TEST_EQUALS( v > u, true, TEST_LOCATION );
+ u = Uint16Pair(1u, 0u);
+ v = Uint16Pair(0u, 1u);
+ DALI_TEST_EQUALS(v > u, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairFromFloatVecP(void)
{
- Dali::Vector2 v2( 5.f, 5.f );
+ Dali::Vector2 v2(5.f, 5.f);
- Uint16Pair u = Uint16Pair::FromFloatVec2( v2 );
- DALI_TEST_EQUALS( u.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( u.GetY(), 5u, TEST_LOCATION );
+ Uint16Pair u = Uint16Pair::FromFloatVec2(v2);
+ DALI_TEST_EQUALS(u.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(u.GetY(), 5u, TEST_LOCATION);
- Dali::Vector3 v3( 5.f, 5.f, 5.f );
+ Dali::Vector3 v3(5.f, 5.f, 5.f);
- u = Uint16Pair::FromFloatVec2( v3 );
- DALI_TEST_EQUALS( u.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( u.GetY(), 5u, TEST_LOCATION );
+ u = Uint16Pair::FromFloatVec2(v3);
+ DALI_TEST_EQUALS(u.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(u.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
int UtcDaliUint16PairFromFloatArrayP(void)
{
- float array[] = { 5.f, 5.f };
+ float array[] = {5.f, 5.f};
- Uint16Pair u = Uint16Pair::FromFloatArray( array );
- DALI_TEST_EQUALS( u.GetX(), 5u, TEST_LOCATION );
- DALI_TEST_EQUALS( u.GetY(), 5u, TEST_LOCATION );
+ Uint16Pair u = Uint16Pair::FromFloatArray(array);
+ DALI_TEST_EQUALS(u.GetX(), 5u, TEST_LOCATION);
+ DALI_TEST_EQUALS(u.GetY(), 5u, TEST_LOCATION);
END_TEST;
}
#define ENABLE_VECTOR_ASSERTS
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
const Dali::VectorBase::SizeType ZERO(0);
/// Compare a short with an int
-void DALI_TEST_EQUALS( short value1, int value2, const char* location )
+void DALI_TEST_EQUALS(short value1, int value2, const char* location)
{
- ::DALI_TEST_EQUALS< short >( value1, static_cast< short >( value2 ), location );
+ ::DALI_TEST_EQUALS<short>(value1, static_cast<short>(value2), location);
}
/// Compare a char with an int
-void DALI_TEST_EQUALS( char value1, int value2, const char* location )
+void DALI_TEST_EQUALS(char value1, int value2, const char* location)
{
- ::DALI_TEST_EQUALS< char >( value1, static_cast< char >( value2 ), location );
+ ::DALI_TEST_EQUALS<char>(value1, static_cast<char>(value2), location);
}
} // unnamed namespace
{
tet_infoline("Testing Dali::Vector<int>");
- Vector< int > intvector;
+ Vector<int> intvector;
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
intvector.Clear();
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
intvector.Release();
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<int>");
- Vector< int > intvector;
+ Vector<int> intvector;
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
- intvector.PushBack( 11 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( 11, intvector[ 0 ], TEST_LOCATION );
+ intvector.PushBack(11);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), intvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(11, intvector[0], TEST_LOCATION);
- intvector.PushBack( 99 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( 99, intvector[ 1 ], TEST_LOCATION );
+ intvector.PushBack(99);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), intvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(99, intvector[1], TEST_LOCATION);
- intvector.PushBack( 34 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(6), intvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( 11, intvector[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 99, intvector[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 34, intvector[ 2 ], TEST_LOCATION );
+ intvector.PushBack(34);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(6), intvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(11, intvector[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(99, intvector[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(34, intvector[2], TEST_LOCATION);
intvector.Clear();
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(6), intvector.Capacity(), TEST_LOCATION );
- intvector.PushBack( 123 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 123, intvector[ 0 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(6), intvector.Capacity(), TEST_LOCATION);
+ intvector.PushBack(123);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(123, intvector[0], TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<int>::Copy");
- Vector< int > intvector;
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
+ Vector<int> intvector;
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
- intvector.PushBack( 99 );
- intvector.PushBack( 11 );
- intvector.PushBack( 34 );
+ intvector.PushBack(99);
+ intvector.PushBack(11);
+ intvector.PushBack(34);
// copy construct
- Vector< int > intvector2( intvector );
+ Vector<int> intvector2(intvector);
- DALI_TEST_EQUALS( intvector2.Count(), intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( intvector2.Capacity(), intvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( intvector2[ 0 ], intvector[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( intvector2[ 1 ], intvector[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( intvector2[ 2 ], intvector[ 2 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(intvector2.Count(), intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(intvector2.Capacity(), intvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(intvector2[0], intvector[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(intvector2[1], intvector[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(intvector2[2], intvector[2], TEST_LOCATION);
// assign
- Vector< int > intvector3;
- DALI_TEST_EQUALS( ZERO, intvector3.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector3.Capacity(), TEST_LOCATION );
+ Vector<int> intvector3;
+ DALI_TEST_EQUALS(ZERO, intvector3.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector3.Capacity(), TEST_LOCATION);
intvector2 = intvector3;
- DALI_TEST_EQUALS( intvector2.Count(), intvector3.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( intvector2.Capacity(), intvector3.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(intvector2.Count(), intvector3.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(intvector2.Capacity(), intvector3.Capacity(), TEST_LOCATION);
// copy empty
- Vector< int > intvector4;
- intvector4.Reserve( 100 );
- DALI_TEST_EQUALS( ZERO, intvector4.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(100), intvector4.Capacity(), TEST_LOCATION );
+ Vector<int> intvector4;
+ intvector4.Reserve(100);
+ DALI_TEST_EQUALS(ZERO, intvector4.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(100), intvector4.Capacity(), TEST_LOCATION);
intvector3 = intvector4;
- DALI_TEST_EQUALS( ZERO, intvector3.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(100), intvector3.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector3.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(100), intvector3.Capacity(), TEST_LOCATION);
// self copy
intvector4 = intvector4;
- DALI_TEST_EQUALS( ZERO, intvector4.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(100), intvector4.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, intvector4.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(100), intvector4.Capacity(), TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<short>::Resize");
- Vector< short > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
-
- vector.Resize( 10u );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(10), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION );
-
- vector.Resize( 4u );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION );
-
- vector.Resize( 4u );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION );
-
- vector.Resize( 0u );
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION );
-
- vector.Resize( 12u, 123 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(12), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(12), vector.Capacity(), TEST_LOCATION );
-
- DALI_TEST_EQUALS( vector[ 0 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 5 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 6 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 7 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 8 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 9 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 10 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 11 ], 123, TEST_LOCATION );
-
- vector.Resize( 13u, 321 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(13), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(13), vector.Capacity(), TEST_LOCATION );
-
- DALI_TEST_EQUALS( vector[ 0 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 5 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 6 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 7 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 8 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 9 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 10 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 11 ], 123, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 12 ], 321, TEST_LOCATION );
+ Vector<short> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
+
+ vector.Resize(10u);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(10), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION);
+
+ vector.Resize(4u);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION);
+
+ vector.Resize(4u);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION);
+
+ vector.Resize(0u);
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(10), vector.Capacity(), TEST_LOCATION);
+
+ vector.Resize(12u, 123);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(12), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(12), vector.Capacity(), TEST_LOCATION);
+
+ DALI_TEST_EQUALS(vector[0], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[5], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[6], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[7], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[8], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[9], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[10], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[11], 123, TEST_LOCATION);
+
+ vector.Resize(13u, 321);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(13), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(13), vector.Capacity(), TEST_LOCATION);
+
+ DALI_TEST_EQUALS(vector[0], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[5], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[6], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[7], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[8], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[9], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[10], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[11], 123, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[12], 321, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<short>::Erase");
- Vector< char > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
- vector.PushBack( 1 );
- vector.PushBack( 2 );
- vector.PushBack( 3 );
- vector.PushBack( 4 );
- vector.PushBack( 5 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(5), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 5, TEST_LOCATION );
-
- vector.Erase( vector.Begin() );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 5, TEST_LOCATION );
-
- Vector< char >::Iterator ret = vector.Erase( std::find( vector.Begin(), vector.End(), 4 ) );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 5, TEST_LOCATION );
- DALI_TEST_EQUALS( *ret, 5, TEST_LOCATION );
+ Vector<char> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
+ vector.PushBack(1);
+ vector.PushBack(2);
+ vector.PushBack(3);
+ vector.PushBack(4);
+ vector.PushBack(5);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(5), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 5, TEST_LOCATION);
+
+ vector.Erase(vector.Begin());
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 5, TEST_LOCATION);
+
+ Vector<char>::Iterator ret = vector.Erase(std::find(vector.Begin(), vector.End(), 4));
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(*ret, 5, TEST_LOCATION);
// try erasing last
- vector.PushBack( 99 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 99, TEST_LOCATION );
- ret = vector.Erase( vector.End() - 1 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ret, vector.End(), TEST_LOCATION );
+ vector.PushBack(99);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 99, TEST_LOCATION);
+ ret = vector.Erase(vector.End() - 1);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ret, vector.End(), TEST_LOCATION);
try
{
// illegal erase, one past the end
- vector.Erase( vector.End() );
+ vector.Erase(vector.End());
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
// illegal erase, one before the begin
- vector.Erase( vector.Begin() - 1u );
+ vector.Erase(vector.Begin() - 1u);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 5, TEST_LOCATION);
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 5, TEST_LOCATION );
-
- vector.Erase( vector.Begin() + 1 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 5, TEST_LOCATION );
+ vector.Erase(vector.Begin() + 1);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 5, TEST_LOCATION);
- vector.Erase( vector.Begin() + 1 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 2, TEST_LOCATION );
+ vector.Erase(vector.Begin() + 1);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 2, TEST_LOCATION);
try
{
// illegal erase, one past the end
- vector.Erase( vector.Begin() + 1 );
+ vector.Erase(vector.Begin() + 1);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 2, TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 2, TEST_LOCATION);
- vector.Erase( vector.Begin() );
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
+ vector.Erase(vector.Begin());
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
try
{
// illegal erase, one before the beginning
- vector.Erase( vector.Begin() - 1 );
+ vector.Erase(vector.Begin() - 1);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.Begin(), vector.End(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.Begin(), vector.End(), TEST_LOCATION);
- Vector< char >::Iterator endIter = vector.End();
- for( Vector< char >::Iterator iter = vector.Begin(); iter != endIter; ++iter )
+ Vector<char>::Iterator endIter = vector.End();
+ for(Vector<char>::Iterator iter = vector.Begin(); iter != endIter; ++iter)
{
tet_result(TET_FAIL);
}
- vector.PushBack( 3 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION );
+ vector.PushBack(3);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION);
vector.Clear();
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector.Begin(), vector.End(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector.Begin(), vector.End(), TEST_LOCATION);
endIter = vector.End();
- for( Vector< char >::Iterator iter = vector.Begin(); iter != endIter; ++iter )
+ for(Vector<char>::Iterator iter = vector.Begin(); iter != endIter; ++iter)
{
tet_result(TET_FAIL);
}
// test a vector of pointers
- Vector< int* > ptrVector;
- DALI_TEST_EQUALS( ZERO, ptrVector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ptrVector.Begin(), ptrVector.End(), TEST_LOCATION );
+ Vector<int*> ptrVector;
+ DALI_TEST_EQUALS(ZERO, ptrVector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ptrVector.Begin(), ptrVector.End(), TEST_LOCATION);
int* pointer = NULL;
- ptrVector.PushBack( pointer );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), ptrVector.Count(), TEST_LOCATION );
-
- Vector< int* >::Iterator ptriter = std::find( ptrVector.Begin(), ptrVector.End(), pointer );
- ptriter = ptrVector.Erase( ptriter );
- DALI_TEST_EQUALS( ZERO, ptrVector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ptrVector.Begin(), ptrVector.End(), TEST_LOCATION );
- DALI_TEST_EQUALS( ptrVector.Begin(), ptriter, TEST_LOCATION );
+ ptrVector.PushBack(pointer);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), ptrVector.Count(), TEST_LOCATION);
+
+ Vector<int*>::Iterator ptriter = std::find(ptrVector.Begin(), ptrVector.End(), pointer);
+ ptriter = ptrVector.Erase(ptriter);
+ DALI_TEST_EQUALS(ZERO, ptrVector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ptrVector.Begin(), ptrVector.End(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ptrVector.Begin(), ptriter, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliVectorDoubleRemove(void)
{
tet_infoline("Testing Dali::Vector<double>::Remove");
- Vector< double > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
-
- vector.PushBack( 11.1 );
- vector.PushBack( 22.2 );
- vector.PushBack( 33.3 );
- vector.PushBack( 44.4 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 11.1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 22.2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 33.3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 44.4, TEST_LOCATION );
-
- Vector< double >::Iterator res = std::find( vector.Begin(), vector.End(), 22.2 );
- DALI_TEST_EQUALS( 22.2, *res, TEST_LOCATION );
- vector.Remove( res );
- res = std::find( vector.Begin(), vector.End(), 22.2 );
- DALI_TEST_EQUALS( vector.End(), res, TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 11.1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 44.4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 33.3, TEST_LOCATION );
-
- vector.Remove( vector.End() - 1 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 11.1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 44.4, TEST_LOCATION );
-
- vector.Remove( vector.Begin() );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 44.4, TEST_LOCATION );
+ Vector<double> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+
+ vector.PushBack(11.1);
+ vector.PushBack(22.2);
+ vector.PushBack(33.3);
+ vector.PushBack(44.4);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 11.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 22.2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 33.3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 44.4, TEST_LOCATION);
+
+ Vector<double>::Iterator res = std::find(vector.Begin(), vector.End(), 22.2);
+ DALI_TEST_EQUALS(22.2, *res, TEST_LOCATION);
+ vector.Remove(res);
+ res = std::find(vector.Begin(), vector.End(), 22.2);
+ DALI_TEST_EQUALS(vector.End(), res, TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 11.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 44.4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 33.3, TEST_LOCATION);
+
+ vector.Remove(vector.End() - 1);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 11.1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 44.4, TEST_LOCATION);
+
+ vector.Remove(vector.Begin());
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 44.4, TEST_LOCATION);
try
{
// illegal erase, one past the end
- vector.Remove( vector.Begin() + 1 );
+ vector.Remove(vector.Begin() + 1);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 44.4, TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 44.4, TEST_LOCATION);
- vector.Remove( vector.Begin() );
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
+ vector.Remove(vector.Begin());
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
try
{
// illegal erase, one before the beginning
- vector.Remove( vector.Begin() - 1 );
+ vector.Remove(vector.Begin() - 1);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
{
tet_infoline("Testing Dali::Vector<int>::Swap");
- Vector< int > intvector;
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
-
- intvector.PushBack( 11 );
- intvector.PushBack( 22 );
- intvector.PushBack( 33 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION );
-
- Vector< int > intvector2;
- DALI_TEST_EQUALS( ZERO, intvector2.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector2.Capacity(), TEST_LOCATION );
-
- intvector2.Swap( intvector );
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector2.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 11, intvector2[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 22, intvector2[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 33, intvector2[ 2 ], TEST_LOCATION );
-
- intvector.PushBack( 99 );
- intvector.PushBack( 88 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector.Count(), TEST_LOCATION );
-
- intvector.Swap( intvector2 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), intvector2.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 99, intvector2[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 88, intvector2[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 11, intvector[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 22, intvector[ 1 ], TEST_LOCATION );
- DALI_TEST_EQUALS( 33, intvector[ 2 ], TEST_LOCATION );
-
- Vector< int > empty;
- intvector.Swap( empty );
- DALI_TEST_EQUALS( ZERO, intvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intvector.Capacity(), TEST_LOCATION );
+ Vector<int> intvector;
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
+
+ intvector.PushBack(11);
+ intvector.PushBack(22);
+ intvector.PushBack(33);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION);
+
+ Vector<int> intvector2;
+ DALI_TEST_EQUALS(ZERO, intvector2.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector2.Capacity(), TEST_LOCATION);
+
+ intvector2.Swap(intvector);
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), intvector2.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(11, intvector2[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(22, intvector2[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(33, intvector2[2], TEST_LOCATION);
+
+ intvector.PushBack(99);
+ intvector.PushBack(88);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), intvector.Count(), TEST_LOCATION);
+
+ intvector.Swap(intvector2);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), intvector2.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(99, intvector2[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(88, intvector2[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(11, intvector[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(22, intvector[1], TEST_LOCATION);
+ DALI_TEST_EQUALS(33, intvector[2], TEST_LOCATION);
+
+ Vector<int> empty;
+ intvector.Swap(empty);
+ DALI_TEST_EQUALS(ZERO, intvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intvector.Capacity(), TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<float>::Begin");
- Vector< float > floatvector;
- DALI_TEST_EQUALS( ZERO, floatvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, floatvector.Capacity(), TEST_LOCATION );
+ Vector<float> floatvector;
+ DALI_TEST_EQUALS(ZERO, floatvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, floatvector.Capacity(), TEST_LOCATION);
- floatvector.PushBack( 0.9f );
- floatvector.PushBack( 1.1f );
- floatvector.PushBack( 1.2f );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), floatvector.Count(), TEST_LOCATION );
+ floatvector.PushBack(0.9f);
+ floatvector.PushBack(1.1f);
+ floatvector.PushBack(1.2f);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), floatvector.Count(), TEST_LOCATION);
- Vector< float >::Iterator iter = floatvector.Begin();
- int index = 0;
- for( ; iter != floatvector.End(); ++iter, ++index )
+ Vector<float>::Iterator iter = floatvector.Begin();
+ int index = 0;
+ for(; iter != floatvector.End(); ++iter, ++index)
{
std::cout << "value " << *iter << std::endl;
- DALI_TEST_EQUALS( *iter, floatvector[ index ], TEST_LOCATION );
+ DALI_TEST_EQUALS(*iter, floatvector[index], TEST_LOCATION);
}
- DALI_TEST_EQUALS( 3, index, TEST_LOCATION );
+ DALI_TEST_EQUALS(3, index, TEST_LOCATION);
- iter = std::find( floatvector.Begin(), floatvector.End(), 1.1f );
- DALI_TEST_EQUALS( 1.1f, *iter, TEST_LOCATION );
+ iter = std::find(floatvector.Begin(), floatvector.End(), 1.1f);
+ DALI_TEST_EQUALS(1.1f, *iter, TEST_LOCATION);
floatvector.Clear();
- iter = std::find( floatvector.Begin(), floatvector.End(), 1.1f );
- DALI_TEST_EQUALS( floatvector.End(), iter, TEST_LOCATION );
+ iter = std::find(floatvector.Begin(), floatvector.End(), 1.1f);
+ DALI_TEST_EQUALS(floatvector.End(), iter, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector< std::pair< int, float > >");
- Vector< std::pair< int, float > > pairvector;
- DALI_TEST_EQUALS( ZERO, pairvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, pairvector.Capacity(), TEST_LOCATION );
+ Vector<std::pair<int, float> > pairvector;
+ DALI_TEST_EQUALS(ZERO, pairvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, pairvector.Capacity(), TEST_LOCATION);
- pairvector.PushBack( std::make_pair( 5, 0.1f ) );
- pairvector.PushBack( std::make_pair( 3, 0.2f ) );
- pairvector.PushBack( std::make_pair( 4, 0.3f ) );
- pairvector.PushBack( std::make_pair( 1, 0.4f ) );
- pairvector.PushBack( std::make_pair( 2, 0.5f ) );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(5), pairvector.Count(), TEST_LOCATION );
+ pairvector.PushBack(std::make_pair(5, 0.1f));
+ pairvector.PushBack(std::make_pair(3, 0.2f));
+ pairvector.PushBack(std::make_pair(4, 0.3f));
+ pairvector.PushBack(std::make_pair(1, 0.4f));
+ pairvector.PushBack(std::make_pair(2, 0.5f));
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(5), pairvector.Count(), TEST_LOCATION);
- Vector< std::pair< int, float > >::Iterator iter = pairvector.Begin();
- int index = 0;
- for( ; iter != pairvector.End(); ++iter, ++index )
+ Vector<std::pair<int, float> >::Iterator iter = pairvector.Begin();
+ int index = 0;
+ for(; iter != pairvector.End(); ++iter, ++index)
{
std::cout << "pair " << (*iter).first << ":" << (*iter).second << std::endl;
- DALI_TEST_EQUALS( (*iter).first, pairvector[ index ].first, TEST_LOCATION );
- DALI_TEST_EQUALS( (*iter).second, pairvector[ index ].second, TEST_LOCATION );
+ DALI_TEST_EQUALS((*iter).first, pairvector[index].first, TEST_LOCATION);
+ DALI_TEST_EQUALS((*iter).second, pairvector[index].second, TEST_LOCATION);
}
END_TEST;
}
tet_infoline("Testing Dali::Vector< int* > exception handling");
// empty vector
- Vector< int* > pointervector;
+ Vector<int*> pointervector;
try
{
- int* value = NULL;
- pointervector[ 1 ] = value;
- tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ int* value = NULL;
+ pointervector[1] = value;
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "VectorBase::mData", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "VectorBase::mData", TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
int* value = NULL;
- value = pointervector[ 0 ];
+ value = pointervector[0];
(void)value; // to "use" the value
- tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "VectorBase::mData", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "VectorBase::mData", TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
- Vector< int* >::Iterator iter = pointervector.Begin();
- if( iter != pointervector.End() )
+ Vector<int*>::Iterator iter = pointervector.Begin();
+ if(iter != pointervector.End())
{
tet_result(TET_FAIL);
}
try
{
- pointervector.Erase( pointervector.Begin() );
- tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ pointervector.Erase(pointervector.Begin());
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
iter = pointervector.Begin();
- if( iter != pointervector.End() )
+ if(iter != pointervector.End())
{
tet_result(TET_FAIL);
}
try
{
- pointervector.Remove( pointervector.Begin() );
- tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ pointervector.Remove(pointervector.Begin());
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(iterator < End()) && (iterator >= Begin())", TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
iter = pointervector.Begin();
- if( iter != pointervector.End() )
+ if(iter != pointervector.End())
{
tet_result(TET_FAIL);
}
// reserve 0 space
- pointervector.Reserve( 0 );
+ pointervector.Reserve(0);
iter = pointervector.Begin();
- if( iter != pointervector.End() )
+ if(iter != pointervector.End())
{
tet_result(TET_FAIL);
}
// reserve 1 space
- pointervector.Reserve( 1 );
+ pointervector.Reserve(1);
iter = pointervector.Begin();
- if( iter != pointervector.End() )
+ if(iter != pointervector.End())
{
tet_result(TET_FAIL);
}
try
{
- int* value = NULL;
- pointervector[ 1 ] = value;
- tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ int* value = NULL;
+ pointervector[1] = value;
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "index < VectorBase::Count()", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "index < VectorBase::Count()", TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
- int* value = pointervector[ 1 ];
+ int* value = pointervector[1];
(void)value; // to "use" the value
- tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "index < VectorBase::Count()", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "index < VectorBase::Count()", TEST_LOCATION);
}
catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
tet_infoline("Testing multiple Dali::Vector's");
// create multiple vectors
- Vector< std::pair< float, float > > pairvector;
- DALI_TEST_EQUALS( ZERO, pairvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, pairvector.Capacity(), TEST_LOCATION );
- Vector< double > doublevector;
- DALI_TEST_EQUALS( ZERO, doublevector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, doublevector.Capacity(), TEST_LOCATION );
- Vector< int* > intptrvector;
- DALI_TEST_EQUALS( ZERO, intptrvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intptrvector.Capacity(), TEST_LOCATION );
- Vector< Dali::Actor* > actorptrvector;
- DALI_TEST_EQUALS( ZERO, actorptrvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, actorptrvector.Capacity(), TEST_LOCATION );
- Vector< long > longvector;
- DALI_TEST_EQUALS( ZERO, longvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, longvector.Capacity(), TEST_LOCATION );
- Vector< char > charvector;
- DALI_TEST_EQUALS( ZERO, charvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, charvector.Capacity(), TEST_LOCATION );
+ Vector<std::pair<float, float> > pairvector;
+ DALI_TEST_EQUALS(ZERO, pairvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, pairvector.Capacity(), TEST_LOCATION);
+ Vector<double> doublevector;
+ DALI_TEST_EQUALS(ZERO, doublevector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, doublevector.Capacity(), TEST_LOCATION);
+ Vector<int*> intptrvector;
+ DALI_TEST_EQUALS(ZERO, intptrvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intptrvector.Capacity(), TEST_LOCATION);
+ Vector<Dali::Actor*> actorptrvector;
+ DALI_TEST_EQUALS(ZERO, actorptrvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, actorptrvector.Capacity(), TEST_LOCATION);
+ Vector<long> longvector;
+ DALI_TEST_EQUALS(ZERO, longvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, longvector.Capacity(), TEST_LOCATION);
+ Vector<char> charvector;
+ DALI_TEST_EQUALS(ZERO, charvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, charvector.Capacity(), TEST_LOCATION);
// add items
static unsigned int acidCount = 10000;
- int* ptr = NULL;
- for( unsigned int i = 0; i < acidCount; ++i )
+ int* ptr = NULL;
+ for(unsigned int i = 0; i < acidCount; ++i)
{
- pairvector.PushBack( std::make_pair( i, i ) );
- doublevector.PushBack( (double)i );
- intptrvector.PushBack( (int*)ptr );
- actorptrvector.PushBack( (Dali::Actor*)ptr );
- longvector.PushBack( (long)i );
- charvector.PushBack( (char)i );
+ pairvector.PushBack(std::make_pair(i, i));
+ doublevector.PushBack((double)i);
+ intptrvector.PushBack((int*)ptr);
+ actorptrvector.PushBack((Dali::Actor*)ptr);
+ longvector.PushBack((long)i);
+ charvector.PushBack((char)i);
}
- DALI_TEST_EQUALS( acidCount, pairvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(acidCount, pairvector.Count(), TEST_LOCATION);
std::size_t pairCapacity = pairvector.Capacity();
- DALI_TEST_EQUALS( acidCount, doublevector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(acidCount, doublevector.Count(), TEST_LOCATION);
std::size_t doubleCapacity = doublevector.Capacity();
- DALI_TEST_EQUALS( acidCount, intptrvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(acidCount, intptrvector.Count(), TEST_LOCATION);
std::size_t intptrCapacity = intptrvector.Capacity();
- DALI_TEST_EQUALS( acidCount, actorptrvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(acidCount, actorptrvector.Count(), TEST_LOCATION);
std::size_t actorptrCapacity = actorptrvector.Capacity();
- DALI_TEST_EQUALS( acidCount, longvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(acidCount, longvector.Count(), TEST_LOCATION);
std::size_t longCapacity = longvector.Capacity();
- DALI_TEST_EQUALS( acidCount, charvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(acidCount, charvector.Count(), TEST_LOCATION);
std::size_t charCapacity = charvector.Capacity();
- tet_printf("Dali::Vector< pair > capacity after %d pushbacks is %d", acidCount, pairCapacity );
- tet_printf("Dali::Vector< double > capacity after %d pushbacks is %d", acidCount, doubleCapacity );
- tet_printf("Dali::Vector< int* > capacity after %d pushbacks is %d", acidCount, intptrCapacity );
- tet_printf("Dali::Vector< Actor* > capacity after %d pushbacks is %d", acidCount, actorptrCapacity );
- tet_printf("Dali::Vector< long > capacity after %d pushbacks is %d", acidCount, longCapacity );
- tet_printf("Dali::Vector< char > capacity after %d pushbacks is %d", acidCount, charCapacity );
+ tet_printf("Dali::Vector< pair > capacity after %d pushbacks is %d", acidCount, pairCapacity);
+ tet_printf("Dali::Vector< double > capacity after %d pushbacks is %d", acidCount, doubleCapacity);
+ tet_printf("Dali::Vector< int* > capacity after %d pushbacks is %d", acidCount, intptrCapacity);
+ tet_printf("Dali::Vector< Actor* > capacity after %d pushbacks is %d", acidCount, actorptrCapacity);
+ tet_printf("Dali::Vector< long > capacity after %d pushbacks is %d", acidCount, longCapacity);
+ tet_printf("Dali::Vector< char > capacity after %d pushbacks is %d", acidCount, charCapacity);
// erase items
- for( unsigned int i = 0; i < acidCount; ++i )
- {
- pairvector.Erase( pairvector.Begin() + ( i % pairvector.Count() ) );
- doublevector.Erase( doublevector.Begin() + ( i % doublevector.Count() ) );
- intptrvector.Erase( intptrvector.Begin() + ( i % intptrvector.Count() ) );
- actorptrvector.Erase( actorptrvector.Begin() + ( i % actorptrvector.Count() ) );
- longvector.Erase( longvector.Begin() + ( i % longvector.Count() ) );
- charvector.Erase( charvector.Begin() + ( i % charvector.Count() ) );
- }
- DALI_TEST_EQUALS( ZERO, pairvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( pairCapacity, pairvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, doublevector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( doubleCapacity, doublevector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, intptrvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( intptrCapacity, intptrvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, actorptrvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( actorptrCapacity, actorptrvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, longvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( longCapacity, longvector.Capacity(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, charvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( charCapacity, charvector.Capacity(), TEST_LOCATION );
+ for(unsigned int i = 0; i < acidCount; ++i)
+ {
+ pairvector.Erase(pairvector.Begin() + (i % pairvector.Count()));
+ doublevector.Erase(doublevector.Begin() + (i % doublevector.Count()));
+ intptrvector.Erase(intptrvector.Begin() + (i % intptrvector.Count()));
+ actorptrvector.Erase(actorptrvector.Begin() + (i % actorptrvector.Count()));
+ longvector.Erase(longvector.Begin() + (i % longvector.Count()));
+ charvector.Erase(charvector.Begin() + (i % charvector.Count()));
+ }
+ DALI_TEST_EQUALS(ZERO, pairvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(pairCapacity, pairvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, doublevector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(doubleCapacity, doublevector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, intptrvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(intptrCapacity, intptrvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, actorptrvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(actorptrCapacity, actorptrvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, longvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(longCapacity, longvector.Capacity(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, charvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(charCapacity, charvector.Capacity(), TEST_LOCATION);
END_TEST;
}
int UtcDaliVectorPushBack(void)
{
- tet_infoline( "Testing Dali::Vector< int* >PushBack(Element)" );
+ tet_infoline("Testing Dali::Vector< int* >PushBack(Element)");
Vector<unsigned int> vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
- vector.Reserve( 2u );
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 2u, vector.Capacity(), TEST_LOCATION );
+ vector.Reserve(2u);
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(2u, vector.Capacity(), TEST_LOCATION);
- vector.PushBack( 0u );
- vector.PushBack( 1u );
- vector.PushBack( 2u );
+ vector.PushBack(0u);
+ vector.PushBack(1u);
+ vector.PushBack(2u);
- DALI_TEST_EQUALS( 3u, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 6u, vector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(3u, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(6u, vector.Capacity(), TEST_LOCATION);
- vector.PushBack( 3u );
+ vector.PushBack(3u);
- DALI_TEST_EQUALS( 4u, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 6u, vector.Capacity(), TEST_LOCATION );
+ DALI_TEST_EQUALS(4u, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(6u, vector.Capacity(), TEST_LOCATION);
- DALI_TEST_EQUALS( 0u, vector[0u], TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, vector[1u], TEST_LOCATION );
- DALI_TEST_EQUALS( 2u, vector[2u], TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, vector[3u], TEST_LOCATION );
+ DALI_TEST_EQUALS(0u, vector[0u], TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, vector[1u], TEST_LOCATION);
+ DALI_TEST_EQUALS(2u, vector[2u], TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, vector[3u], TEST_LOCATION);
END_TEST;
}
int UtcDaliVectorInsert01(void)
{
- tet_infoline( "Testing Dali::Vector< int* >Insert(Iterator, Element)" );
+ tet_infoline("Testing Dali::Vector< int* >Insert(Iterator, Element)");
// Test order of array inserted-into:
- Vector< unsigned int > orderedVector;
- orderedVector.PushBack( 9u );
- for( unsigned int i = 8u; i <= 8u; --i )
+ Vector<unsigned int> orderedVector;
+ orderedVector.PushBack(9u);
+ for(unsigned int i = 8u; i <= 8u; --i)
{
- orderedVector.Insert( orderedVector.Begin(), i );
- DALI_TEST_EQUALS( 10u - i, orderedVector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( i, orderedVector[0u], TEST_LOCATION );
+ orderedVector.Insert(orderedVector.Begin(), i);
+ DALI_TEST_EQUALS(10u - i, orderedVector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(i, orderedVector[0u], TEST_LOCATION);
}
- for( unsigned int i = 0u; i < 10u; ++i )
+ for(unsigned int i = 0u; i < 10u; ++i)
{
- DALI_TEST_EQUALS( i, orderedVector[i], TEST_LOCATION );
+ DALI_TEST_EQUALS(i, orderedVector[i], TEST_LOCATION);
}
// Test insertion out of range in non-empty array throws:
try
{
- orderedVector.Insert( orderedVector.Begin() + 99u, 99u );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ orderedVector.Insert(orderedVector.Begin() + 99u, 99u);
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( at <= End() ) && ( at >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(at <= End()) && (at >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf( "Assertion test failed - wrong Exception\n" );
- tet_result( TET_FAIL );
+ tet_printf("Assertion test failed - wrong Exception\n");
+ tet_result(TET_FAIL);
}
try
{
- orderedVector.Insert( orderedVector.Begin() - 1u, 99u );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
- tet_result( TET_FAIL );
+ orderedVector.Insert(orderedVector.Begin() - 1u, 99u);
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
+ tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( at <= End() ) && ( at >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(at <= End()) && (at >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf( "Assertion test failed - wrong Exception\n" );
- tet_result( TET_FAIL );
+ tet_printf("Assertion test failed - wrong Exception\n");
+ tet_result(TET_FAIL);
}
// Test insertion part-way through a largish array retains ordering:
// Build vector with hole in sequence:
- Vector< unsigned int > longerVector;
- const unsigned int insertionPoint = 131571u;
- const unsigned int finalLength = 262143u;
- for( unsigned int i = 0u; i < insertionPoint; ++i )
+ Vector<unsigned int> longerVector;
+ const unsigned int insertionPoint = 131571u;
+ const unsigned int finalLength = 262143u;
+ for(unsigned int i = 0u; i < insertionPoint; ++i)
{
- longerVector.PushBack( i );
+ longerVector.PushBack(i);
}
- for( unsigned int i = insertionPoint; i < finalLength; ++i )
+ for(unsigned int i = insertionPoint; i < finalLength; ++i)
{
- longerVector.PushBack( i + 1 );
+ longerVector.PushBack(i + 1);
}
// Fill the hole in the sequence:
- longerVector.Insert( longerVector.Begin() + insertionPoint, insertionPoint );
+ longerVector.Insert(longerVector.Begin() + insertionPoint, insertionPoint);
// Check the sequence is monotonically increasing by one every time:
- for( unsigned int i = 0u; i <= finalLength; ++i )
+ for(unsigned int i = 0u; i <= finalLength; ++i)
{
- DALI_TEST_EQUALS( i, longerVector[i], TEST_LOCATION );
+ DALI_TEST_EQUALS(i, longerVector[i], TEST_LOCATION);
}
// Insert into an empty vector
- Vector< unsigned int > vector;
+ Vector<unsigned int> vector;
- vector.Insert( vector.End(), orderedVector.Begin(), orderedVector.End() );
- for( unsigned int i = 0u; i < 10u; ++i )
+ vector.Insert(vector.End(), orderedVector.Begin(), orderedVector.End());
+ for(unsigned int i = 0u; i < 10u; ++i)
{
- DALI_TEST_EQUALS( i, vector[i], TEST_LOCATION );
+ DALI_TEST_EQUALS(i, vector[i], TEST_LOCATION);
}
vector.Clear();
- vector.Insert( vector.Begin(), orderedVector.Begin(), orderedVector.End() );
- for( unsigned int i = 0u; i < 10u; ++i )
+ vector.Insert(vector.Begin(), orderedVector.Begin(), orderedVector.End());
+ for(unsigned int i = 0u; i < 10u; ++i)
{
- DALI_TEST_EQUALS( i, vector[i], TEST_LOCATION );
+ DALI_TEST_EQUALS(i, vector[i], TEST_LOCATION);
}
// Insert nothing.
- vector.Insert( vector.Begin(), orderedVector.Begin(), orderedVector.Begin() );
- for( unsigned int i = 0u; i < 10u; ++i )
+ vector.Insert(vector.Begin(), orderedVector.Begin(), orderedVector.Begin());
+ for(unsigned int i = 0u; i < 10u; ++i)
{
- DALI_TEST_EQUALS( i, vector[i], TEST_LOCATION );
+ DALI_TEST_EQUALS(i, vector[i], TEST_LOCATION);
}
- vector.Insert( vector.Begin() + 5, vector.Begin() + 5, vector.Begin() + 5 );
- for( unsigned int i = 0u; i < 10u; ++i )
+ vector.Insert(vector.Begin() + 5, vector.Begin() + 5, vector.Begin() + 5);
+ for(unsigned int i = 0u; i < 10u; ++i)
{
- DALI_TEST_EQUALS( i, vector[i], TEST_LOCATION );
+ DALI_TEST_EQUALS(i, vector[i], TEST_LOCATION);
}
// AutoInsert
vector.Clear();
- vector.PushBack( 0u );
- vector.PushBack( 1u );
- vector.PushBack( 2u );
- vector.PushBack( 3u );
-
- vector.Insert( vector.Begin() + 2, vector.Begin(), vector.End() );
- DALI_TEST_EQUALS( 8u, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, vector[0u], TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, vector[1u], TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, vector[2u], TEST_LOCATION );
- DALI_TEST_EQUALS( 1u, vector[3u], TEST_LOCATION );
- DALI_TEST_EQUALS( 2u, vector[4u], TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, vector[5u], TEST_LOCATION );
- DALI_TEST_EQUALS( 2u, vector[6u], TEST_LOCATION );
- DALI_TEST_EQUALS( 3u, vector[7u], TEST_LOCATION );
+ vector.PushBack(0u);
+ vector.PushBack(1u);
+ vector.PushBack(2u);
+ vector.PushBack(3u);
+
+ vector.Insert(vector.Begin() + 2, vector.Begin(), vector.End());
+ DALI_TEST_EQUALS(8u, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, vector[0u], TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, vector[1u], TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, vector[2u], TEST_LOCATION);
+ DALI_TEST_EQUALS(1u, vector[3u], TEST_LOCATION);
+ DALI_TEST_EQUALS(2u, vector[4u], TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, vector[5u], TEST_LOCATION);
+ DALI_TEST_EQUALS(2u, vector[6u], TEST_LOCATION);
+ DALI_TEST_EQUALS(3u, vector[7u], TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<char>::Insert(Iterator,Iterator,Iterator)");
- Vector< char > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
- vector.PushBack( 1 );
- vector.PushBack( 2 );
- vector.PushBack( 3 );
- vector.PushBack( 4 );
- vector.PushBack( 5 );
-
- Vector< char > vector2;
- DALI_TEST_EQUALS( ZERO, vector2.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector2.Capacity(), TEST_LOCATION );
- vector2.PushBack( 6 );
- vector2.PushBack( 7 );
- vector2.PushBack( 8 );
- vector2.PushBack( 9 );
- vector2.PushBack( 10 );
+ Vector<char> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
+ vector.PushBack(1);
+ vector.PushBack(2);
+ vector.PushBack(3);
+ vector.PushBack(4);
+ vector.PushBack(5);
+
+ Vector<char> vector2;
+ DALI_TEST_EQUALS(ZERO, vector2.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector2.Capacity(), TEST_LOCATION);
+ vector2.PushBack(6);
+ vector2.PushBack(7);
+ vector2.PushBack(8);
+ vector2.PushBack(9);
+ vector2.PushBack(10);
// Test insert at end
- vector.Insert( vector.End(), vector2.Begin(), vector2.Begin() + 1u );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(6), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 5, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 5 ], 6, TEST_LOCATION );
+ vector.Insert(vector.End(), vector2.Begin(), vector2.Begin() + 1u);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(6), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[5], 6, TEST_LOCATION);
// Test insert at begin
- vector.Insert( vector.Begin(), vector2.Begin()+1, vector2.Begin() + 2u );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(7), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 7, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 5 ], 5, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 6 ], 6, TEST_LOCATION );
+ vector.Insert(vector.Begin(), vector2.Begin() + 1, vector2.Begin() + 2u);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(7), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 7, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[5], 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[6], 6, TEST_LOCATION);
// Test insert in the middle
- vector.Insert( vector.Begin() + 3, vector2.Begin()+3, vector2.End() );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(9), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 7, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 9, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 10, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 5 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 6 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 7 ], 5, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 8 ], 6, TEST_LOCATION );
+ vector.Insert(vector.Begin() + 3, vector2.Begin() + 3, vector2.End());
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(9), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 7, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 9, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 10, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[5], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[6], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[7], 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[8], 6, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<char>::Insert(Iterator,Iterator,Iterator) asserts");
- Vector< char > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
- vector.PushBack( 1 );
- vector.PushBack( 2 );
-
- Vector< char > vector2;
- DALI_TEST_EQUALS( ZERO, vector2.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector2.Capacity(), TEST_LOCATION );
- vector2.PushBack( 6 );
- vector2.PushBack( 7 );
- vector2.PushBack( 8 );
- vector2.PushBack( 9 );
- vector2.PushBack( 10 );
+ Vector<char> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
+ vector.PushBack(1);
+ vector.PushBack(2);
+
+ Vector<char> vector2;
+ DALI_TEST_EQUALS(ZERO, vector2.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector2.Capacity(), TEST_LOCATION);
+ vector2.PushBack(6);
+ vector2.PushBack(7);
+ vector2.PushBack(8);
+ vector2.PushBack(9);
+ vector2.PushBack(10);
try
{
- vector.Insert( vector.Begin() + 3u, vector2.Begin(), vector2.End() );
+ vector.Insert(vector.Begin() + 3u, vector2.Begin(), vector2.End());
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( at <= End() ) && ( at >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(at <= End()) && (at >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
- vector.Insert( vector.Begin() - 1u, vector2.Begin(), vector2.End() );
+ vector.Insert(vector.Begin() - 1u, vector2.Begin(), vector2.End());
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( at <= End() ) && ( at >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(at <= End()) && (at >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
- vector.Insert( vector.End(), vector2.End(), vector2.Begin() );
+ vector.Insert(vector.End(), vector2.End(), vector2.Begin());
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( from <= to )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(from <= to)", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
END_TEST;
- }
-
+}
int UtcDaliVectorIntEraseRange(void)
{
tet_infoline("Testing Dali::Vector<char>::Erase(Iterator,Iterator)");
- Vector< char > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
+ Vector<char> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
// Try to delete from empty vector.
- vector.Erase( vector.Begin(), vector.End() );
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
-
- vector.PushBack( 1 );
- vector.PushBack( 2 );
- vector.PushBack( 3 );
- vector.PushBack( 4 );
- vector.PushBack( 5 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(5), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 2, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 4 ], 5, TEST_LOCATION );
-
- Vector< char >::Iterator ret;
-
- ret = vector.Erase( vector.Begin() + 1u, vector.Begin() + 2u );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 1, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 3, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 5, TEST_LOCATION );
- DALI_TEST_EQUALS( *ret, 3, TEST_LOCATION );
-
- ret = vector.Erase( vector.Begin(), vector.Begin() + 2 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(2), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 5, TEST_LOCATION );
- DALI_TEST_EQUALS( *ret, 4, TEST_LOCATION );
+ vector.Erase(vector.Begin(), vector.End());
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
+
+ vector.PushBack(1);
+ vector.PushBack(2);
+ vector.PushBack(3);
+ vector.PushBack(4);
+ vector.PushBack(5);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(5), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 2, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[4], 5, TEST_LOCATION);
+
+ Vector<char>::Iterator ret;
+
+ ret = vector.Erase(vector.Begin() + 1u, vector.Begin() + 2u);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 1, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 3, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(*ret, 3, TEST_LOCATION);
+
+ ret = vector.Erase(vector.Begin(), vector.Begin() + 2);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(2), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 5, TEST_LOCATION);
+ DALI_TEST_EQUALS(*ret, 4, TEST_LOCATION);
// try erasing last
- vector.PushBack( 99 );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 99, TEST_LOCATION );
- ret = vector.Erase( vector.Begin() + 1u, vector.End() );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( ret, vector.End(), TEST_LOCATION );
+ vector.PushBack(99);
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 99, TEST_LOCATION);
+ ret = vector.Erase(vector.Begin() + 1u, vector.End());
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(1), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(ret, vector.End(), TEST_LOCATION);
// try erasing all
- vector.PushBack( 100 );
- vector.PushBack( 101 );
- vector.PushBack( 102 );
+ vector.PushBack(100);
+ vector.PushBack(101);
+ vector.PushBack(102);
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 4, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 100, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 101, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 3 ], 102, TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(4), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 4, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 100, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 101, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[3], 102, TEST_LOCATION);
- ret = vector.Erase( vector.Begin(), vector.End() );
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(0), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ret, vector.End(), TEST_LOCATION );
+ ret = vector.Erase(vector.Begin(), vector.End());
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(0), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ret, vector.End(), TEST_LOCATION);
// try erase from Iterator to the same Iterator.
- vector.PushBack( 100 );
- vector.PushBack( 101 );
- vector.PushBack( 102 );
+ vector.PushBack(100);
+ vector.PushBack(101);
+ vector.PushBack(102);
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 100, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 101, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 102, TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 100, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 101, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 102, TEST_LOCATION);
- ret = vector.Erase( vector.Begin() + 1, vector.Begin() + 1 );
+ ret = vector.Erase(vector.Begin() + 1, vector.Begin() + 1);
- DALI_TEST_EQUALS( static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 0 ], 100, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 1 ], 101, TEST_LOCATION );
- DALI_TEST_EQUALS( vector[ 2 ], 102, TEST_LOCATION );
+ DALI_TEST_EQUALS(static_cast<Dali::VectorBase::SizeType>(3), vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[0], 100, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[1], 101, TEST_LOCATION);
+ DALI_TEST_EQUALS(vector[2], 102, TEST_LOCATION);
- DALI_TEST_EQUALS( *ret, 101, TEST_LOCATION );
+ DALI_TEST_EQUALS(*ret, 101, TEST_LOCATION);
END_TEST;
}
{
tet_infoline("Testing Dali::Vector<char>::Erase(Iterator,Iterator) asserts");
- Vector< char > vector;
- DALI_TEST_EQUALS( ZERO, vector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, vector.Capacity(), TEST_LOCATION );
-
+ Vector<char> vector;
+ DALI_TEST_EQUALS(ZERO, vector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, vector.Capacity(), TEST_LOCATION);
// Add some elements.
- vector.PushBack( 1 );
- vector.PushBack( 2 );
+ vector.PushBack(1);
+ vector.PushBack(2);
// first out of bounds
try
{
- vector.Erase( vector.Begin() + 3u, vector.Begin() + 4u );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ vector.Erase(vector.Begin() + 3u, vector.Begin() + 4u);
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( first <= End() ) && ( first >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(first <= End()) && (first >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
- vector.Erase( vector.Begin() - 1u, vector.End() );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ vector.Erase(vector.Begin() - 1u, vector.End());
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( first <= End() ) && ( first >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(first <= End()) && (first >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
- vector.Erase( vector.Begin(), vector.Begin() + 3u );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ vector.Erase(vector.Begin(), vector.Begin() + 3u);
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( last <= End() ) && ( last >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(last <= End()) && (last >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
try
{
- vector.Erase( vector.Begin(), vector.Begin() - 1u );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ vector.Erase(vector.Begin(), vector.Begin() - 1u);
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( last <= End() ) && ( last >= Begin() )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(last <= End()) && (last >= Begin())", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
- vector.PushBack( 3 );
+ vector.PushBack(3);
// first > last
try
{
- vector.Erase( vector.Begin() + 2u, vector.Begin() + 1u );
- tet_printf( "Assertion expected, but not occurred at %s\n", TEST_LOCATION );
+ vector.Erase(vector.Begin() + 2u, vector.Begin() + 1u);
+ tet_printf("Assertion expected, but not occurred at %s\n", TEST_LOCATION);
tet_result(TET_FAIL);
}
- catch( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "( first <= last )", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "(first <= last)", TEST_LOCATION);
}
- catch( ... )
+ catch(...)
{
- tet_printf("Assertion test failed - wrong Exception\n" );
+ tet_printf("Assertion test failed - wrong Exception\n");
tet_result(TET_FAIL);
}
{
tet_infoline("Testing Dali::Vector< Vector2 >");
- Vector< Vector2 > classvector;
- DALI_TEST_EQUALS( ZERO, classvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, classvector.Capacity(), TEST_LOCATION );
+ Vector<Vector2> classvector;
+ DALI_TEST_EQUALS(ZERO, classvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, classvector.Capacity(), TEST_LOCATION);
- classvector.PushBack( Vector2() );
+ classvector.PushBack(Vector2());
- DALI_TEST_EQUALS( 1u, classvector.Count(), TEST_LOCATION );
- DALI_TEST_GREATER( classvector.Capacity(), ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(1u, classvector.Count(), TEST_LOCATION);
+ DALI_TEST_GREATER(classvector.Capacity(), ZERO, TEST_LOCATION);
- classvector.PushBack( Vector2( 0.1f, 0.2f ) );
+ classvector.PushBack(Vector2(0.1f, 0.2f));
- DALI_TEST_EQUALS( 2u, classvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(2u, classvector.Count(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector2(), classvector[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( Vector2( 0.1f, 0.2f ), classvector[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector2(), classvector[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector2(0.1f, 0.2f), classvector[1], TEST_LOCATION);
tet_result(TET_PASS); // for now
END_TEST;
{
tet_infoline("Testing Dali::Vector< Vector3 >");
- Vector< Vector3 > classvector;
- DALI_TEST_EQUALS( ZERO, classvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, classvector.Capacity(), TEST_LOCATION );
+ Vector<Vector3> classvector;
+ DALI_TEST_EQUALS(ZERO, classvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, classvector.Capacity(), TEST_LOCATION);
- classvector.PushBack( Vector3() );
+ classvector.PushBack(Vector3());
- DALI_TEST_EQUALS( 1u, classvector.Count(), TEST_LOCATION );
- DALI_TEST_GREATER( classvector.Capacity(), ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(1u, classvector.Count(), TEST_LOCATION);
+ DALI_TEST_GREATER(classvector.Capacity(), ZERO, TEST_LOCATION);
- classvector.PushBack( Vector3( 0.1f, 0.2f, 0.3f ) );
+ classvector.PushBack(Vector3(0.1f, 0.2f, 0.3f));
- DALI_TEST_EQUALS( 2u, classvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(2u, classvector.Count(), TEST_LOCATION);
- DALI_TEST_EQUALS( Vector3(), classvector[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), classvector[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(), classvector[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), classvector[1], TEST_LOCATION);
tet_result(TET_PASS); // for now
END_TEST;
{
tet_infoline("Testing Dali::Vector< Matrix >");
- Vector< Matrix > classvector;
- DALI_TEST_EQUALS( ZERO, classvector.Count(), TEST_LOCATION );
- DALI_TEST_EQUALS( ZERO, classvector.Capacity(), TEST_LOCATION );
+ Vector<Matrix> classvector;
+ DALI_TEST_EQUALS(ZERO, classvector.Count(), TEST_LOCATION);
+ DALI_TEST_EQUALS(ZERO, classvector.Capacity(), TEST_LOCATION);
- classvector.PushBack( Matrix() );
+ classvector.PushBack(Matrix());
- DALI_TEST_EQUALS( 1u, classvector.Count(), TEST_LOCATION );
- DALI_TEST_GREATER( classvector.Capacity(), ZERO, TEST_LOCATION );
+ DALI_TEST_EQUALS(1u, classvector.Count(), TEST_LOCATION);
+ DALI_TEST_GREATER(classvector.Capacity(), ZERO, TEST_LOCATION);
- classvector.PushBack( Matrix::IDENTITY );
+ classvector.PushBack(Matrix::IDENTITY);
- DALI_TEST_EQUALS( 2u, classvector.Count(), TEST_LOCATION );
+ DALI_TEST_EQUALS(2u, classvector.Count(), TEST_LOCATION);
- DALI_TEST_EQUALS( Matrix(), classvector[ 0 ], TEST_LOCATION );
- DALI_TEST_EQUALS( Matrix::IDENTITY, classvector[ 1 ], TEST_LOCATION );
+ DALI_TEST_EQUALS(Matrix(), classvector[0], TEST_LOCATION);
+ DALI_TEST_EQUALS(Matrix::IDENTITY, classvector[1], TEST_LOCATION);
tet_result(TET_PASS); // for now
END_TEST;
int UtcDaliVectorCpp11ForP(void)
{
- Vector< Vector3 > classvector;
- for ( auto i : classvector )
+ Vector<Vector3> classvector;
+ for(auto i : classvector)
{
std::ignore = i;
- tet_result( TET_FAIL );
+ tet_result(TET_FAIL);
}
- classvector.PushBack( Vector3( 0.1f, 0.2f, 0.3f ) );
- classvector.PushBack( Vector3( 0.1f, 0.2f, 0.3f ) );
- classvector.PushBack( Vector3( 0.1f, 0.2f, 0.3f ) );
+ classvector.PushBack(Vector3(0.1f, 0.2f, 0.3f));
+ classvector.PushBack(Vector3(0.1f, 0.2f, 0.3f));
+ classvector.PushBack(Vector3(0.1f, 0.2f, 0.3f));
- for ( auto i : classvector )
+ for(auto i : classvector)
{
- DALI_TEST_EQUALS( Vector3( 0.1f, 0.2f, 0.3f ), i, TEST_LOCATION );
+ DALI_TEST_EQUALS(Vector3(0.1f, 0.2f, 0.3f), i, TEST_LOCATION);
}
END_TEST;
movedFrom.PushBack(Vector3::NEGATIVE_ZAXIS);
Vector<Vector3> movedTo(std::move(movedFrom));
- DALI_TEST_EQUALS( movedTo.Size(), 3u, TEST_LOCATION);
- DALI_TEST_EQUALS( movedFrom.Size(), 0u, TEST_LOCATION);
+ DALI_TEST_EQUALS(movedTo.Size(), 3u, TEST_LOCATION);
+ DALI_TEST_EQUALS(movedFrom.Size(), 0u, TEST_LOCATION);
END_TEST;
}
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <cmath> // isfinite
#include <iostream>
#include <sstream>
-#include <cmath> // isfinite
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
using namespace Dali;
int UtcDaliVector2Constructor01P(void)
{
TestApplication application;
- Vector2 vec2;
+ Vector2 vec2;
DALI_TEST_EQUALS(vec2.x, 0.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 0.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2Constructor02P(void)
{
TestApplication application;
- Vector2 vec2(1.f,1.f);
+ Vector2 vec2(1.f, 1.f);
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2Constructor03P(void)
{
TestApplication application;
- float array[] = {1.f,1.f};
- Vector2 vec2(array);
+ float array[] = {1.f, 1.f};
+ Vector2 vec2(array);
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2Constructor04P(void)
{
TestApplication application;
- Vector3 vec3(1.f,1.f,1.f);
- Vector3 vec2(vec3);
+ Vector3 vec3(1.f, 1.f, 1.f);
+ Vector3 vec2(vec3);
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2Constructor05P(void)
{
TestApplication application;
- Vector4 vec4(1.f,1.f,1.f,1.f);
- Vector2 vec2(vec4);
+ Vector4 vec4(1.f, 1.f, 1.f, 1.f);
+ Vector2 vec2(vec4);
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2ConstructorUint16PairP(void)
{
TestApplication application;
- Uint16Pair pair( 20, 30 );
- Vector2 vec2(pair);
+ Uint16Pair pair(20, 30);
+ Vector2 vec2(pair);
DALI_TEST_EQUALS(vec2.x, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 30.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2CopyConstructor01P(void)
{
TestApplication application;
- float array[] = {1.f,1.f};
- Vector2 vec2;
+ float array[] = {1.f, 1.f};
+ Vector2 vec2;
vec2 = array;
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
int UtcDaliVector2CopyConstructor02P(void)
{
TestApplication application;
- Vector3 vec3(1.f,1.f,1.f);
- Vector3 vec2;
+ Vector3 vec3(1.f, 1.f, 1.f);
+ Vector3 vec2;
vec2 = vec3;
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
int UtcDaliVector2CopyConstructor03P(void)
{
TestApplication application;
- Vector4 vec4(1.f,1.f,1.f,1.f);
- Vector3 vec2;
+ Vector4 vec4(1.f, 1.f, 1.f, 1.f);
+ Vector3 vec2;
vec2 = vec4;
DALI_TEST_EQUALS(vec2.x, 1.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec2.y, 1.0f, 0.001, TEST_LOCATION);
int UtcDaliVector2CopyConstructor04P(void)
{
TestApplication application;
- Vector2 vec0( 10.f, 20.f );
- Vector2 vec1( vec0 );
+ Vector2 vec0(10.f, 20.f);
+ Vector2 vec1(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector2MoveConstructor(void)
{
TestApplication application;
- Vector2 vec0( 10.f, 20.f );
- Vector2 vec1 = std::move( vec0 );
+ Vector2 vec0(10.f, 20.f);
+ Vector2 vec1 = std::move(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
int UtcDaliVector2CopyAssignment(void)
{
TestApplication application;
- Vector2 vec0( 10.f, 20.f );
- Vector2 vec1;
+ Vector2 vec0(10.f, 20.f);
+ Vector2 vec1;
vec1 = vec0;
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
int UtcDaliVector2MoveAssignment(void)
{
TestApplication application;
- Vector2 vec0( 10.f, 20.f );
- Vector2 vec1;
- vec1 = std::move( vec0 );
+ Vector2 vec0(10.f, 20.f);
+ Vector2 vec1;
+ vec1 = std::move(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
int UtcDaliVector2AssignP(void)
{
TestApplication application;
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(11.0f, 22.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(11.0f, 22.0f);
v1 = r0;
DALI_TEST_EQUALS(v1, r0, TEST_LOCATION);
int UtcDaliVector2AssignP02(void)
{
TestApplication application;
- Vector2 v1(10.0f, 20.0f);
- Vector4 r0(11.0f, 22.0f, 33.f, 44.f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector4 r0(11.0f, 22.0f, 33.f, 44.f);
v1 = r0;
DALI_TEST_EQUALS(v1, Vector2(r0.x, r0.y), TEST_LOCATION);
int UtcDaliVector2AssignP03(void)
{
TestApplication application;
- Vector2 v1(10.0f, 20.0f);
- Vector3 r0(11.0f, 22.0f, 33.f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector3 r0(11.0f, 22.0f, 33.f);
v1 = r0;
DALI_TEST_EQUALS(v1, Vector2(r0.x, r0.y), TEST_LOCATION);
int UtcDaliVector2AddP(void)
{
TestApplication application;
- Vector2 v0(1.0f, 2.0f);
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(11.0f, 22.0f);
+ Vector2 v0(1.0f, 2.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(11.0f, 22.0f);
- Vector2 v2 = v0+v1;
+ Vector2 v2 = v0 + v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2AddAssignP(void)
{
TestApplication application;
- Vector2 v0(1.0f, 2.0f);
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(11.0f, 22.0f);
+ Vector2 v0(1.0f, 2.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(11.0f, 22.0f);
v0 += v1;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
int UtcDaliVector2SubtractP(void)
{
TestApplication application;
- Vector2 v0(11.0f, 22.0f);
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(1.0f, 2.0f);
+ Vector2 v0(11.0f, 22.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(1.0f, 2.0f);
- Vector2 v2 = v0-v1;
+ Vector2 v2 = v0 - v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
int UtcDaliVector2SubtractAssignP(void)
{
TestApplication application;
- Vector2 v0(11.0f, 22.0f);
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(1.0f, 2.0f);
+ Vector2 v0(11.0f, 22.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(1.0f, 2.0f);
v0 -= v1;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
int UtcDaliVector2NegateP(void)
{
TestApplication application;
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(-10.0f, -20.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(-10.0f, -20.0f);
Vector2 v2 = -v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
int UtcDaliVector2Multiply01P(void)
{
TestApplication application;
- Vector2 v0(2.0f, 3.0f);
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(20.0f, 60.0f);
+ Vector2 v0(2.0f, 3.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(20.0f, 60.0f);
Vector2 v2 = v0 * v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
int UtcDaliVector2Multiply02P(void)
{
TestApplication application;
- Vector2 v0(2.0f, 3.0f);
- Vector2 r0(20.0f, 30.0f);
+ Vector2 v0(2.0f, 3.0f);
+ Vector2 r0(20.0f, 30.0f);
Vector2 v2 = v0 * 10.f;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
int UtcDaliVector2MultiplyAssign01P(void)
{
TestApplication application;
- Vector2 v0(2.0f, 3.0f);
- Vector2 v1(10.0f, 20.0f);
- Vector2 r0(20.0f, 60.0f);
+ Vector2 v0(2.0f, 3.0f);
+ Vector2 v1(10.0f, 20.0f);
+ Vector2 r0(20.0f, 60.0f);
v0 *= v1;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
int UtcDaliVector2MultiplyAssign02P(void)
{
TestApplication application;
- Vector2 v0(2.0f, 3.0f);
- Vector2 r0(20.0f, 30.0f);
+ Vector2 v0(2.0f, 3.0f);
+ Vector2 r0(20.0f, 30.0f);
v0 *= 10.f;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
int UtcDaliVector2Divide01P(void)
{
TestApplication application;
- Vector2 v0(1.0f, 1.0f);
- Vector2 v1(2.0f, 3.0f);
- Vector2 v2(4.0f, 9.0f);
+ Vector2 v0(1.0f, 1.0f);
+ Vector2 v1(2.0f, 3.0f);
+ Vector2 v2(4.0f, 9.0f);
- DALI_TEST_EQUALS( v0/v0, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/v0, v1, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/v1, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v2/v1, v1, TEST_LOCATION);
+ DALI_TEST_EQUALS(v0 / v0, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / v0, v1, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / v1, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v2 / v1, v1, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2Divide02P(void)
{
TestApplication application;
- Vector2 v0(1.0f, 1.0f);
- Vector2 v1(3.0f, 3.0f);
- Vector2 v2(9.0f, 9.0f);
+ Vector2 v0(1.0f, 1.0f);
+ Vector2 v1(3.0f, 3.0f);
+ Vector2 v2(9.0f, 9.0f);
- DALI_TEST_EQUALS( v0/1.f, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/1.f, v1, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/3.f, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v0 / 1.f, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / 1.f, v1, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / 3.f, v0, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2DivideAssign01P(void)
{
TestApplication application;
- Vector2 v0(1.0f, 1.0f);
- Vector2 v1(2.0f, 3.0f);
- Vector2 v2(4.0f, 9.0f);
+ Vector2 v0(1.0f, 1.0f);
+ Vector2 v1(2.0f, 3.0f);
+ Vector2 v2(4.0f, 9.0f);
Vector2 v4(v0);
v4 /= v0;
int UtcDaliVector2DivideAssign02P(void)
{
TestApplication application;
- Vector2 v0(1.0f, 1.0f);
- Vector2 v1(3.0f, 3.0f);
+ Vector2 v0(1.0f, 1.0f);
+ Vector2 v1(3.0f, 3.0f);
Vector2 v4(v0);
v4 /= 1.f;
int UtcDaliVector2EqualsP(void)
{
TestApplication application;
- Vector2 v0(1.0f, 2.0f);
- Vector2 v1(1.0f, 2.0f);
+ Vector2 v0(1.0f, 2.0f);
+ Vector2 v1(1.0f, 2.0f);
DALI_TEST_CHECK(v0 == v1);
int UtcDaliVector2NotEqualsP(void)
{
TestApplication application;
- Vector2 v0(1.0f, 2.0f);
- Vector2 v1(1.0f, 2.0f);
+ Vector2 v0(1.0f, 2.0f);
+ Vector2 v1(1.0f, 2.0f);
Vector2 v2 = Vector2(0.0f, 2.0f);
DALI_TEST_CHECK(v0 != v2);
int UtcDaliVector2OperatorSubscriptP(void)
{
TestApplication application;
- Vector2 testVector(1.0f, 2.0f);
+ Vector2 testVector(1.0f, 2.0f);
// read array subscripts
- DALI_TEST_EQUALS( testVector[0], 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[1], 2.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector[0], 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[1], 2.0f, TEST_LOCATION);
// write array subscripts/read struct memebers
testVector[0] = 3.0f;
testVector[1] = 4.0f;
- DALI_TEST_EQUALS( testVector.x, 3.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector.y, 4.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector.x, 3.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector.y, 4.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2OperatorSubscriptN(void)
{
TestApplication application;
- Vector2 testVector(1.0f, 2.0f);
+ Vector2 testVector(1.0f, 2.0f);
try
{
(void)w; // Suppress unused variable warning
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "Vector element index out of bounds", TEST_LOCATION);
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "Vector element index out of bounds", TEST_LOCATION);
}
END_TEST;
int UtcDaliVector2OperatorConstSubscriptP(void)
{
TestApplication application;
- const Vector2 testVector2(3.0f, 4.0f);
- const float& x = testVector2[0];
- const float& y = testVector2[1];
- DALI_TEST_EQUALS( x, 3.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( y, 4.0f, TEST_LOCATION );
+ const Vector2 testVector2(3.0f, 4.0f);
+ const float& x = testVector2[0];
+ const float& y = testVector2[1];
+ DALI_TEST_EQUALS(x, 3.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(y, 4.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2OperatorConstSubscriptN(void)
{
TestApplication application;
- const Vector2 testVector2(3.0f, 4.0f);
+ const Vector2 testVector2(3.0f, 4.0f);
try
{
(void)w; // Suppress unused variable warning
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "Vector element index out of bounds" , TEST_LOCATION);
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "Vector element index out of bounds", TEST_LOCATION);
}
-
END_TEST;
}
-
int UtcDaliVector2LengthP(void)
{
TestApplication application;
- Vector2 v(1.0f, 2.0f);
- DALI_TEST_EQUALS(v.Length(), sqrtf(v.x*v.x + v.y*v.y), 0.001f, TEST_LOCATION);
+ Vector2 v(1.0f, 2.0f);
+ DALI_TEST_EQUALS(v.Length(), sqrtf(v.x * v.x + v.y * v.y), 0.001f, TEST_LOCATION);
Vector2 v1(0.0f, 0.0f);
DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
int UtcDaliVector2LengthSquaredP(void)
{
TestApplication application;
- Vector2 v(1.0f, 2.0f);
- DALI_TEST_EQUALS(v.LengthSquared(), v.x*v.x + v.y*v.y, 0.001f, TEST_LOCATION);
+ Vector2 v(1.0f, 2.0f);
+ DALI_TEST_EQUALS(v.LengthSquared(), v.x * v.x + v.y * v.y, 0.001f, TEST_LOCATION);
Vector2 v1(0.0f, 0.0f);
DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
int UtcDaliVector2NormalizeP(void)
{
TestApplication application;
- for (float f=0.0f; f<6.0f; f+=1.0f)
+ for(float f = 0.0f; f < 6.0f; f += 1.0f)
{
- Vector2 v(cosf(f)*10.0f, cosf(f+1.0f)*10.0f);
+ Vector2 v(cosf(f) * 10.0f, cosf(f + 1.0f) * 10.0f);
v.Normalize();
DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
}
int UtcDaliVector2NormalizeN(void)
{
TestApplication application;
- Vector2 v(0.0f, 0.0f);
+ Vector2 v(0.0f, 0.0f);
v.Normalize();
DALI_TEST_EQUALS(v.LengthSquared(), 0.0f, 0.00001f, TEST_LOCATION);
END_TEST;
Vector2 min(1.0f, 4.0f);
Vector2 max(9.0f, 6.0f);
- v0.Clamp( min, max );
- v1.Clamp( min, max );
- v2.Clamp( min, max );
- v3.Clamp( min, max );
- v4.Clamp( min, max );
+ v0.Clamp(min, max);
+ v1.Clamp(min, max);
+ v2.Clamp(min, max);
+ v3.Clamp(min, max);
+ v4.Clamp(min, max);
- DALI_TEST_EQUALS( v0, Vector2(2.0f, 4.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v1, Vector2(1.0f, 4.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v2, Vector2(9.0f, 5.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v3, Vector2(8.0f, 6.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v4, Vector2(4.9f, 5.1f), 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(v0, Vector2(2.0f, 4.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1, Vector2(1.0f, 4.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v2, Vector2(9.0f, 5.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v3, Vector2(8.0f, 6.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v4, Vector2(4.9f, 5.1f), 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2AsFloatP(void)
{
TestApplication application;
- Vector2 vec2(1.f,1.f);
- float* p = vec2.AsFloat();
+ Vector2 vec2(1.f, 1.f);
+ float* p = vec2.AsFloat();
- DALI_TEST_EQUALS( p[0], 1.f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( p[1], 1.f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(p[0], 1.f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(p[1], 1.f, 0.01f, TEST_LOCATION);
p[0] = 2.f;
p[1] = 2.f;
- DALI_TEST_EQUALS( p[0], 2.f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( p[1], 2.f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(p[0], 2.f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(p[1], 2.f, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2ConstAsFloatP(void)
{
TestApplication application;
- Vector2 vec2(1.f,1.f);
- const float* p = vec2.AsFloat();
+ Vector2 vec2(1.f, 1.f);
+ const float* p = vec2.AsFloat();
- DALI_TEST_EQUALS( p[0], 1.f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( p[1], 1.f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(p[0], 1.f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(p[1], 1.f, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2XWidthP(void)
{
TestApplication application;
- Vector2 vec2(1.f,1.f);
+ Vector2 vec2(1.f, 1.f);
- DALI_TEST_EQUALS( vec2.x, 1.f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( vec2.width, 1.f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(vec2.x, 1.f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(vec2.width, 1.f, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2YHeightP(void)
{
TestApplication application;
- Vector2 vec2(1.f,1.f);
+ Vector2 vec2(1.f, 1.f);
- DALI_TEST_EQUALS( vec2.y, 1.f, 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( vec2.height, 1.f, 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(vec2.y, 1.f, 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(vec2.height, 1.f, 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector2OStreamOperatorP(void)
{
- TestApplication application;
+ TestApplication application;
std::ostringstream oss;
Vector2 vector(1, 2);
std::string expectedOutput = "[1, 2]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliVector2MaxP(void)
{
TestApplication application;
- Vector2 v0(2.0f, 1.0f);
- Vector2 v1(1.0f, 2.0f);
+ Vector2 v0(2.0f, 1.0f);
+ Vector2 v1(1.0f, 2.0f);
DALI_TEST_EQUALS(Max(v0, v1), Vector2(2.0f, 2.0f), 0.01f, TEST_LOCATION);
END_TEST;
int UtcDaliVector2MinP(void)
{
TestApplication application;
- Vector2 v0(2.0f, 1.0f);
- Vector2 v1(1.0f, 2.0f);
+ Vector2 v0(2.0f, 1.0f);
+ Vector2 v1(1.0f, 2.0f);
DALI_TEST_EQUALS(Min(v0, v1), Vector2(1.0f, 1.0f), 0.01f, TEST_LOCATION);
END_TEST;
Vector2 v0(2.0f, 0.8f);
Vector2 v1(-1.0f, 2.0f);
- DALI_TEST_EQUALS( Clamp( v0, 0.9f, 1.1f ), Vector2(1.1f, 0.9f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( Clamp( v1, 1.0f, 1.0f ), Vector2(1.0f, 1.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( Clamp( v1, 0.0f, 3.0f ), Vector2(0.0f, 2.0f), 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(Clamp(v0, 0.9f, 1.1f), Vector2(1.1f, 0.9f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Clamp(v1, 1.0f, 1.0f), Vector2(1.0f, 1.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Clamp(v1, 0.0f, 3.0f), Vector2(0.0f, 2.0f), 0.01f, TEST_LOCATION);
END_TEST;
}
-
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <cmath> // isfinite
#include <iostream>
#include <sstream>
-#include <cmath> // isfinite
-
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
using namespace Dali;
int UtcDaliVector3Constructor01P(void)
{
TestApplication application;
- Vector3 va;
+ Vector3 va;
DALI_TEST_EQUALS(va.x, 0.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.y, 0.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Constructor02P(void)
{
TestApplication application;
- Vector3 va(1.f, 1.f, 1.f);
+ Vector3 va(1.f, 1.f, 1.f);
DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.z, 1.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Constructor03P(void)
{
TestApplication application;
- float array [] = {1.f, 1.f, 1.f};
- Vector3 va(array);
+ float array[] = {1.f, 1.f, 1.f};
+ Vector3 va(array);
DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.z, 1.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Constructor04P(void)
{
TestApplication application;
- Vector2 vec2(1.f,1.f);
- Vector3 va(vec2);
+ Vector2 vec2(1.f, 1.f);
+ Vector3 va(vec2);
DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.z, 0.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Constructor05P(void)
{
TestApplication application;
- Vector4 vec4(1.f, 1.f, 1.f, 1.f);
- Vector3 va(vec4);
+ Vector4 vec4(1.f, 1.f, 1.f, 1.f);
+ Vector3 va(vec4);
DALI_TEST_EQUALS(va.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.y, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.z, 1.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3CopyConstructor(void)
{
TestApplication application;
- Vector3 vec0( 10.f, 20.f, 30.0f );
- Vector3 vec1( vec0 );
+ Vector3 vec0(10.f, 20.f, 30.0f);
+ Vector3 vec1(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
int UtcDaliVector3MoveConstructor(void)
{
TestApplication application;
- Vector3 vec0( 10.f, 20.f, 30.0f );
- Vector3 vec1 = std::move( vec0 );
+ Vector3 vec0(10.f, 20.f, 30.0f);
+ Vector3 vec1 = std::move(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
int UtcDaliVector3CopyAssignment(void)
{
TestApplication application;
- Vector3 vec0( 10.f, 20.f, 30.0f );
- Vector3 vec1;
+ Vector3 vec0(10.f, 20.f, 30.0f);
+ Vector3 vec1;
vec1 = vec0;
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
int UtcDaliVector3MoveAssignment(void)
{
TestApplication application;
- Vector3 vec0( 10.f, 20.f, 30.0f );
- Vector3 vec1;
- vec1 = std::move( vec0 );
+ Vector3 vec0(10.f, 20.f, 30.0f);
+ Vector3 vec1;
+ vec1 = std::move(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
int UtcDaliVector3Assign01P(void)
{
TestApplication application;
- Vector3 v0;
- const float array[] = { 1.0f, 2.0f, 3.0f };
- v0 = (const float*)array;
+ Vector3 v0;
+ const float array[] = {1.0f, 2.0f, 3.0f};
+ v0 = (const float*)array;
DALI_TEST_EQUALS(v0.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.y, 2.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Assign02P(void)
{
TestApplication application;
- Vector2 vec2_q(1.0f, 2.0f);
- Vector3 vec3a;
+ Vector2 vec2_q(1.0f, 2.0f);
+ Vector3 vec3a;
vec3a = vec2_q;
DALI_TEST_EQUALS(vec3a.x, 1.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Assign03P(void)
{
TestApplication application;
- Vector4 vec4_q(4.0f, 3.0f, 2.0f, 1.0f);
- Vector3 vec3b;
+ Vector4 vec4_q(4.0f, 3.0f, 2.0f, 1.0f);
+ Vector3 vec3b;
vec3b = vec4_q;
DALI_TEST_EQUALS(vec3b.x, 4.0f, 0.001f, TEST_LOCATION);
int UtcDaliVector3Add01P(void)
{
TestApplication application;
- Vector3 v0(1.0f, 2.0f, 3.0f);
- Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 r0(11.0f, 22.0f, 33.0f);
+ Vector3 v0(1.0f, 2.0f, 3.0f);
+ Vector3 v1(10.0f, 20.0f, 30.0f);
+ Vector3 r0(11.0f, 22.0f, 33.0f);
- Vector3 v2 = v0+v1;
+ Vector3 v2 = v0 + v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
int UtcDaliVector3Add02P(void)
{
TestApplication application;
- Vector3 v0(1.0f, 2.0f, 3.0f);
- Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 r0(11.0f, 22.0f, 33.0f);
+ Vector3 v0(1.0f, 2.0f, 3.0f);
+ Vector3 v1(10.0f, 20.0f, 30.0f);
+ Vector3 r0(11.0f, 22.0f, 33.0f);
v0 += v1;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
int UtcDaliVector3Subtract01P(void)
{
TestApplication application;
- Vector3 v0(11.0f, 22.0f, 33.0f);
- Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 r0(1.0f, 2.0f, 3.0f);
+ Vector3 v0(11.0f, 22.0f, 33.0f);
+ Vector3 v1(10.0f, 20.0f, 30.0f);
+ Vector3 r0(1.0f, 2.0f, 3.0f);
- Vector3 v2 = v0-v1;
+ Vector3 v2 = v0 - v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
int UtcDaliVector3Subtract02P(void)
{
TestApplication application;
- Vector3 v0(11.0f, 22.0f, 33.0f);
- Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 r0(1.0f, 2.0f, 3.0f);
+ Vector3 v0(11.0f, 22.0f, 33.0f);
+ Vector3 v1(10.0f, 20.0f, 30.0f);
+ Vector3 r0(1.0f, 2.0f, 3.0f);
v0 -= v1;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
int UtcDaliVector3Multiply01P(void)
{
TestApplication application;
- Vector3 v0(2.0f, 3.0f, 4.0f);
- Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 r0(20.0f, 60.0f, 120.0f);
+ Vector3 v0(2.0f, 3.0f, 4.0f);
+ Vector3 v1(10.0f, 20.0f, 30.0f);
+ Vector3 r0(20.0f, 60.0f, 120.0f);
Vector3 v2 = v0 * v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
int UtcDaliVector3Multiply02P(void)
{
TestApplication application;
- Vector3 v0(2.0f, 3.0f, 4.0f);
- Vector3 r0(20.0f, 30.0f, 40.0f);
- Vector3 v2 = v0 * 10.f;
+ Vector3 v0(2.0f, 3.0f, 4.0f);
+ Vector3 r0(20.0f, 30.0f, 40.0f);
+ Vector3 v2 = v0 * 10.f;
DALI_TEST_EQUALS(v2, r0, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3Multiply03P(void)
{
TestApplication application;
- Vector3 v0(2.0f, 3.0f, 4.0f);
- Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 r0(20.0f, 60.0f, 120.0f);
+ Vector3 v0(2.0f, 3.0f, 4.0f);
+ Vector3 v1(10.0f, 20.0f, 30.0f);
+ Vector3 r0(20.0f, 60.0f, 120.0f);
v0 *= v1;
DALI_TEST_EQUALS(v0, r0, 0.001, TEST_LOCATION);
END_TEST;
int UtcDaliVector3Multiply04P(void)
{
TestApplication application;
- Vector3 v0(2.0f, 3.0f, 4.0f);
- Vector3 r0(20.0f, 30.0f, 40.0f);
+ Vector3 v0(2.0f, 3.0f, 4.0f);
+ Vector3 r0(20.0f, 30.0f, 40.0f);
v0 *= 10.f;
DALI_TEST_EQUALS(v0, r0, TEST_LOCATION);
END_TEST;
int UtcDaliVector3Multiply05P(void)
{
TestApplication application;
- Vector3 vec3(Vector3::YAXIS);
- Quaternion rotation(Radian(Math::PI_2), Vector3::ZAXIS);
- Vector3 result(-Vector3::XAXIS);
+ Vector3 vec3(Vector3::YAXIS);
+ Quaternion rotation(Radian(Math::PI_2), Vector3::ZAXIS);
+ Vector3 result(-Vector3::XAXIS);
vec3 *= rotation;
- DALI_TEST_EQUALS( vec3, result, 0.001, TEST_LOCATION );
+ DALI_TEST_EQUALS(vec3, result, 0.001, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3Divide01P(void)
{
TestApplication application;
- Vector3 v0(1.0f, 1.0f, 1.0f);
- Vector3 v1(2.0f, 3.0f, 5.0f);
- Vector3 v2(4.0f, 9.0f, 25.0f);
+ Vector3 v0(1.0f, 1.0f, 1.0f);
+ Vector3 v1(2.0f, 3.0f, 5.0f);
+ Vector3 v2(4.0f, 9.0f, 25.0f);
- DALI_TEST_EQUALS( v0/v0, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/v0, v1, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/v1, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v2/v1, v1, TEST_LOCATION);
+ DALI_TEST_EQUALS(v0 / v0, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / v0, v1, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / v1, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v2 / v1, v1, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3Divide02P(void)
{
TestApplication application;
- Vector3 v0(3.0f, 6.0f, 9.0f);
- Vector3 v1(1.0f, 2.0f, 3.0f);
- Vector3 r(3.0f, 3.0f, 3.0f);
- Vector3 v2 = v0 / v1;
+ Vector3 v0(3.0f, 6.0f, 9.0f);
+ Vector3 v1(1.0f, 2.0f, 3.0f);
+ Vector3 r(3.0f, 3.0f, 3.0f);
+ Vector3 v2 = v0 / v1;
DALI_TEST_EQUALS(v2, r, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3Divide03P(void)
{
TestApplication application;
- Vector3 v0(3.0f, 6.0f, 9.0f);
- Vector3 v1(1.0f, 2.0f, 3.0f);
- Vector3 v2 = v0 / 3.f;
+ Vector3 v0(3.0f, 6.0f, 9.0f);
+ Vector3 v1(1.0f, 2.0f, 3.0f);
+ Vector3 v2 = v0 / 3.f;
DALI_TEST_EQUALS(v2, v1, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3Divide04P(void)
{
TestApplication application;
- Vector3 v0(3.0f, 6.0f, 9.0f);
- Vector3 v1(1.0f, 1.0f, 1.0f);
- Vector3 v4(v0);
+ Vector3 v0(3.0f, 6.0f, 9.0f);
+ Vector3 v1(1.0f, 1.0f, 1.0f);
+ Vector3 v4(v0);
v4 /= v0;
DALI_TEST_EQUALS(v4, v1, TEST_LOCATION);
END_TEST;
int UtcDaliVector3Divide05P(void)
{
TestApplication application;
- Vector3 v0(3.0f, 6.0f, 9.0f);
- Vector3 v1(1.0f, 2.0f, 3.0f);
- Vector3 v4(v0);
+ Vector3 v0(3.0f, 6.0f, 9.0f);
+ Vector3 v1(1.0f, 2.0f, 3.0f);
+ Vector3 v4(v0);
v4 /= 3.f;
DALI_TEST_EQUALS(v4, v1, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliVector3NegateP(void)
{
TestApplication application;
- Vector3 v1(10.0f, 20.0f, 30.f);
- Vector3 r0(-10.0f, -20.0f, -30.f);
+ Vector3 v1(10.0f, 20.0f, 30.f);
+ Vector3 r0(-10.0f, -20.0f, -30.f);
Vector3 v2 = -v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
int UtcDaliVector3EqualsP(void)
{
TestApplication application;
- Vector3 v0(1.0f, 2.0f, 3.0f);
- Vector3 v1(1.0f, 2.0f, 3.0f);
+ Vector3 v0(1.0f, 2.0f, 3.0f);
+ Vector3 v1(1.0f, 2.0f, 3.0f);
DALI_TEST_CHECK(v0 == v1);
END_TEST;
int UtcDaliVector3NotEqualsP(void)
{
TestApplication application;
- Vector3 v0(1.0f, 2.0f, 3.0f);
- Vector3 v1(1.0f, 2.0f, 3.0f);
- Vector3 v2 = Vector3(0.0f, 2.0f, 3.0f);
+ Vector3 v0(1.0f, 2.0f, 3.0f);
+ Vector3 v1(1.0f, 2.0f, 3.0f);
+ Vector3 v2 = Vector3(0.0f, 2.0f, 3.0f);
DALI_TEST_CHECK(v0 != v2);
v2 = Vector3(1.0f, 0.0f, 3.0f);
int UtcDaliVector3OperatorSubscriptP(void)
{
TestApplication application;
- Vector3 testVector(1.0f, 2.0f, 3.0f);
+ Vector3 testVector(1.0f, 2.0f, 3.0f);
// read array subscripts
- DALI_TEST_EQUALS( testVector[0], 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[1], 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[2], 3.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector[0], 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[1], 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[2], 3.0f, TEST_LOCATION);
// write array subscripts/read struct memebers
testVector[0] = 4.0f;
testVector[1] = 5.0f;
testVector[2] = 6.0f;
- DALI_TEST_EQUALS( testVector.x, 4.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector.y, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector.z, 6.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector.x, 4.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector.y, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector.z, 6.0f, TEST_LOCATION);
// write struct members/read array subscripts
testVector.x = 7.0f;
testVector.y = 8.0f;
testVector.z = 9.0f;
- DALI_TEST_EQUALS( testVector[0], 7.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[1], 8.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[2], 9.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector[0], 7.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[1], 8.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[2], 9.0f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3ConstOperatorSubscriptP(void)
{
TestApplication application;
- Vector3 testVector(1.0f, 2.0f, 3.0f);
+ Vector3 testVector(1.0f, 2.0f, 3.0f);
// write struct members/read array subscripts
const Vector3 testVector2(1.0f, 2.0f, 3.0f);
- const float& x = testVector2[0];
- const float& y = testVector2[1];
- const float& z ( testVector2[2] );
+ const float& x = testVector2[0];
+ const float& y = testVector2[1];
+ const float& z(testVector2[2]);
- DALI_TEST_EQUALS( x, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( y, 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( z, 3.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(x, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(y, 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(z, 3.0f, TEST_LOCATION);
try
{
(void)w; // Suppress unused variable warning
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "index < 3", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "index < 3", TEST_LOCATION);
}
try
(void)w; // Suppress unused variable warning
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
+ DALI_TEST_PRINT_ASSERT(e);
DALI_TEST_ASSERT(e, "index < 3", TEST_LOCATION);
}
DALI_TEST_EQUALS(Vector3(1.0f, 0.0f, 0.0f).Dot(Vector3(1.0f, 0.0f, 0.0f)), 1.0f, TEST_LOCATION);
- for (float x = 0; x<6.0f; x+=1.0f)
+ for(float x = 0; x < 6.0f; x += 1.0f)
{
Vector3 v0(cosf(x), sinf(x), 0.0f);
Vector3 v1(sinf(x), -cosf(x), 0.0f);
Vector3 v0(2.0f, 3.0f, 4.0f);
Vector3 v1(10.0f, 20.0f, 30.0f);
- Vector3 result( (v0.y * v1.z) - (v0.z * v1.y),
- (v0.z * v1.x) - (v0.x * v1.z),
- (v0.x * v1.y) - (v0.y * v1.x) );
-
+ Vector3 result((v0.y * v1.z) - (v0.z * v1.y),
+ (v0.z * v1.x) - (v0.x * v1.z),
+ (v0.x * v1.y) - (v0.y * v1.x));
DALI_TEST_EQUALS(v0.Cross(v1), result, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliVector3LengthP(void)
{
TestApplication application;
- Vector3 v(1.0f, 2.0f, 3.0f);
- DALI_TEST_EQUALS(v.Length(), sqrtf(v.x*v.x + v.y*v.y + v.z*v.z), 0.001f, TEST_LOCATION);
+ Vector3 v(1.0f, 2.0f, 3.0f);
+ DALI_TEST_EQUALS(v.Length(), sqrtf(v.x * v.x + v.y * v.y + v.z * v.z), 0.001f, TEST_LOCATION);
Vector3 v1(0.0f, 0.0f, 0.0f);
DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
int UtcDaliVector3LengthSquaredP(void)
{
TestApplication application;
- Vector3 v(1.0f, 2.0f, 3.0f);
- DALI_TEST_EQUALS(v.LengthSquared(), v.x*v.x + v.y*v.y + v.z*v.z, 0.001f, TEST_LOCATION);
+ Vector3 v(1.0f, 2.0f, 3.0f);
+ DALI_TEST_EQUALS(v.LengthSquared(), v.x * v.x + v.y * v.y + v.z * v.z, 0.001f, TEST_LOCATION);
Vector3 v1(0.0f, 0.0f, 0.0f);
DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
int UtcDaliVector3NormalizeP(void)
{
TestApplication application;
- for (float f=0.0f; f<6.0f; f+=1.0f)
+ for(float f = 0.0f; f < 6.0f; f += 1.0f)
{
- Vector3 v(cosf(f)*10.0f, cosf(f+1.0f)*10.0f, cosf(f+2.0f)*10.0f);
+ Vector3 v(cosf(f) * 10.0f, cosf(f + 1.0f) * 10.0f, cosf(f + 2.0f) * 10.0f);
v.Normalize();
DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
}
Vector3 min(1.0f, 4.0f, 1.5f);
Vector3 max(9.0f, 6.0f, 8.0f);
- v0.Clamp( min, max );
- v1.Clamp( min, max );
- v2.Clamp( min, max );
- v3.Clamp( min, max );
- v4.Clamp( min, max );
+ v0.Clamp(min, max);
+ v1.Clamp(min, max);
+ v2.Clamp(min, max);
+ v3.Clamp(min, max);
+ v4.Clamp(min, max);
- DALI_TEST_EQUALS( v0, Vector3(2.0f, 4.0f, 1.5f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v1, Vector3(1.0f, 4.0f, 8.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v2, Vector3(9.0f, 5.0f, 1.5f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v3, Vector3(8.0f, 6.0f, 5.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v4, Vector3(4.9f, 5.1f, 8.0f), 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(v0, Vector3(2.0f, 4.0f, 1.5f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1, Vector3(1.0f, 4.0f, 8.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v2, Vector3(9.0f, 5.0f, 1.5f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v3, Vector3(8.0f, 6.0f, 5.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v4, Vector3(4.9f, 5.1f, 8.0f), 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3AsFloatP(void)
{
TestApplication application;
- float values[] = {0.0f, 1.0f, 2.0f};
- Vector3 v0(values);
+ float values[] = {0.0f, 1.0f, 2.0f};
+ Vector3 v0(values);
- for (int i=0;i<3;++i)
+ for(int i = 0; i < 3; ++i)
{
DALI_TEST_EQUALS(v0.AsFloat()[i], values[i], TEST_LOCATION);
}
int UtcDaliVector3ConstAsFloatP(void)
{
TestApplication application;
- float values[] = {0.0f, 1.0f, 2.0f};
- Vector3 v0(values);
+ float values[] = {0.0f, 1.0f, 2.0f};
+ Vector3 v0(values);
const Vector3 v1(values);
- for (int i=0;i<3;++i)
+ for(int i = 0; i < 3; ++i)
{
DALI_TEST_EQUALS(v1.AsFloat()[i], values[i], TEST_LOCATION);
}
int UtcDaliVector3ConstAsVectorXYP(void)
{
TestApplication application;
- float values[] = {0.0f, 1.0f, 2.0f};
- const Vector3 v0(values);
+ float values[] = {0.0f, 1.0f, 2.0f};
+ const Vector3 v0(values);
DALI_TEST_EQUALS(v0.GetVectorXY().x, values[0], TEST_LOCATION);
DALI_TEST_EQUALS(v0.GetVectorXY().y, values[1], TEST_LOCATION);
END_TEST;
int UtcDaliVector3AsVectorXYP(void)
{
TestApplication application;
- float values[] = {0.0f, 1.0f, 2.0f};
- Vector3 v0(values);
+ float values[] = {0.0f, 1.0f, 2.0f};
+ Vector3 v0(values);
DALI_TEST_EQUALS(v0.GetVectorXY().x, values[0], TEST_LOCATION);
DALI_TEST_EQUALS(v0.GetVectorXY().y, values[1], TEST_LOCATION);
int UtcDaliVector3ConstAsVectorXZP(void)
{
TestApplication application;
- float values[] = {0.0f, 1.0f, 2.0f};
- const Vector3 v0(values);
+ float values[] = {0.0f, 1.0f, 2.0f};
+ const Vector3 v0(values);
DALI_TEST_EQUALS(v0.GetVectorYZ().x, values[1], TEST_LOCATION);
DALI_TEST_EQUALS(v0.GetVectorYZ().y, values[2], TEST_LOCATION);
int UtcDaliVector3AsVectorXZP(void)
{
TestApplication application;
- float values[] = {0.0f, 1.0f, 2.0f};
- Vector3 v0(values);
+ float values[] = {0.0f, 1.0f, 2.0f};
+ Vector3 v0(values);
DALI_TEST_EQUALS(v0.GetVectorYZ().x, values[1], TEST_LOCATION);
DALI_TEST_EQUALS(v0.GetVectorYZ().y, values[2], TEST_LOCATION);
int UtcDaliVector3OStreamOperatorP(void)
{
- TestApplication application;
+ TestApplication application;
std::ostringstream oss;
Vector3 vector(1, 2, 3);
std::string expectedOutput = "[1, 2, 3]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3MinP(void)
{
TestApplication application;
- Vector3 v0(2.0f, 2.0f, 1.0f);
- Vector3 v1(1.0f, 1.0f, 2.0f);
+ Vector3 v0(2.0f, 2.0f, 1.0f);
+ Vector3 v1(1.0f, 1.0f, 2.0f);
DALI_TEST_EQUALS(Min(v0, v1), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
END_TEST;
int UtcDaliVector3MaxP(void)
{
TestApplication application;
- Vector3 v0(2.0f, 1.0f, 3.0f);
- Vector3 v1(1.0f, 2.0f, 3.0f);
+ Vector3 v0(2.0f, 1.0f, 3.0f);
+ Vector3 v1(1.0f, 2.0f, 3.0f);
DALI_TEST_EQUALS(Max(v0, v1), Vector3(2.0f, 2.0f, 3.0f), 0.01f, TEST_LOCATION);
END_TEST;
int UtcDaliVector3ClampP(void)
{
TestApplication application;
- Vector3 v0( 2.0f, 1.0f, 0.0f );
- Vector3 v1( -1.0f, 2.0f, 1.0f );
+ Vector3 v0(2.0f, 1.0f, 0.0f);
+ Vector3 v1(-1.0f, 2.0f, 1.0f);
- DALI_TEST_EQUALS( Clamp( v0, 0.9f, 1.1f ), Vector3(1.1f, 1.0f, 0.9f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( Clamp( v1, 1.0f, 1.0f ), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(Clamp(v0, 0.9f, 1.1f), Vector3(1.1f, 1.0f, 0.9f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(Clamp(v1, 1.0f, 1.0f), Vector3(1.0f, 1.0f, 1.0f), 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector3ConstantsP(void)
{
TestApplication application;
- Vector3 va = Vector3::ZERO;
- Vector3 vb = Vector3::ONE;
- Vector3 vc = Vector3::XAXIS;
+ Vector3 va = Vector3::ZERO;
+ Vector3 vb = Vector3::ONE;
+ Vector3 vc = Vector3::XAXIS;
DALI_TEST_EQUALS(va.x, 0.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(va.y, 0.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(vc.z, 0.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
-
*
*/
+#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
#include <iostream>
#include <sstream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali-test-suite-utils.h>
-
using namespace Dali;
void utc_dali_vector4_startup(void)
int UtcDaliVector4Constructor03P(void)
{
- float f [] = {1.0f, 2.0f, 3.0f, 4.f};
+ float f[] = {1.0f, 2.0f, 3.0f, 4.f};
Vector4 v(f);
DALI_TEST_EQUALS(v.x, 1.0f, TEST_LOCATION);
DALI_TEST_EQUALS(v.y, 2.0f, TEST_LOCATION);
int UtcDaliVector4CopyConstructor(void)
{
TestApplication application;
- Vector4 vec0( 10.f, 20.f, 30.0f, 40.0f );
- Vector4 vec1( vec0 );
+ Vector4 vec0(10.f, 20.f, 30.0f, 40.0f);
+ Vector4 vec1(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
int UtcDaliVector4MoveConstructor(void)
{
TestApplication application;
- Vector4 vec0( 10.f, 20.f, 30.0f, 40.0f );
- Vector4 vec1 = std::move( vec0 );
+ Vector4 vec0(10.f, 20.f, 30.0f, 40.0f);
+ Vector4 vec1 = std::move(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
int UtcDaliVector4CopyAssignment(void)
{
TestApplication application;
- Vector4 vec0( 10.f, 20.f, 30.0f, 40.0f );
- Vector4 vec1;
+ Vector4 vec0(10.f, 20.f, 30.0f, 40.0f);
+ Vector4 vec1;
vec1 = vec0;
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
int UtcDaliVector4MoveAssignment(void)
{
TestApplication application;
- Vector4 vec0( 10.f, 20.f, 30.0f, 40.0f );
- Vector4 vec1;
- vec1 = std::move( vec0 );
+ Vector4 vec0(10.f, 20.f, 30.0f, 40.0f);
+ Vector4 vec1;
+ vec1 = std::move(vec0);
DALI_TEST_EQUALS(vec1.x, 10.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.y, 20.0f, 0.001, TEST_LOCATION);
DALI_TEST_EQUALS(vec1.z, 30.0f, 0.001, TEST_LOCATION);
int UtcDaliVector4Assign01P(void)
{
- Vector4 v0;
- const float array[] = { 1.0f, 2.0f, 3.0f, 4.f };
- v0 = (const float*)array;
+ Vector4 v0;
+ const float array[] = {1.0f, 2.0f, 3.0f, 4.f};
+ v0 = (const float*)array;
DALI_TEST_EQUALS(v0.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.y, 2.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.z, 0.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.z, 0.0f, 0.001f, TEST_LOCATION);
v0.w = v0.z = 99.f;
- v0 = vec2;
+ v0 = vec2;
DALI_TEST_EQUALS(v0.x, 1.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.y, 2.0f, 0.001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.z, 0.0f, 0.001f, TEST_LOCATION);
Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
Vector4 r0(11.0f, 22.0f, 33.0f, 44.0f);
- Vector4 v2 = v0+v1;
+ Vector4 v2 = v0 + v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
Vector4 r0(1.0f, 2.0f, 3.0f, 4.0f);
- Vector4 v2 = v0-v1;
+ Vector4 v2 = v0 - v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector4Multiply01P(void)
{
Vector4 v0(2.0f, 3.0f, 4.0f, 5.0f);
- Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
+ Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
Vector4 r0(20.0f, 60.0f, 120.0f, 200.0f);
Vector4 v2 = v0 * v1;
int UtcDaliVector4Multiply02P(void)
{
- Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
+ Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
- Vector4 v2 = v0 * 10.0f;
+ Vector4 v2 = v0 * 10.0f;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector4Multiply03P(void)
{
Vector4 v0(2.0f, 3.0f, 4.0f, 5.0f);
- Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
+ Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
Vector4 r0(20.0f, 60.0f, 120.0f, 200.0f);
v0 *= v1;
int UtcDaliVector4Multiply04P(void)
{
- Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
+ Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
- Vector4 v2(r0);
+ Vector4 v2(r0);
v0 *= 10.0f;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
END_TEST;
Vector4 v1(2.0f, 3.0f, 5.0f, 7.0f);
Vector4 v2(4.0f, 9.0f, 25.0f, 49.0f);
- DALI_TEST_EQUALS( v0/v0, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/v0, v1, TEST_LOCATION);
- DALI_TEST_EQUALS( v1/v1, v0, TEST_LOCATION);
- DALI_TEST_EQUALS( v2/v1, v1, TEST_LOCATION);
-
+ DALI_TEST_EQUALS(v0 / v0, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / v0, v1, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1 / v1, v0, TEST_LOCATION);
+ DALI_TEST_EQUALS(v2 / v1, v1, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector4Divide02P(void)
{
- Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
+ Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
- const Vector4 r1(10.0f, 20.0f, 40.0f, 80.0f);
- const Vector4 r2( 1.0f, 2.0f, 4.0f, 8.0f);
- const Vector4 r3(2.0f, 4.0f, 8.0f, 16.0f);
+ const Vector4 r1(10.0f, 20.0f, 40.0f, 80.0f);
+ const Vector4 r2(1.0f, 2.0f, 4.0f, 8.0f);
+ const Vector4 r3(2.0f, 4.0f, 8.0f, 16.0f);
Vector4 v2 = r0 / 10.0f;
DALI_TEST_EQUALS(v2, r3, TEST_LOCATION);
int UtcDaliVector4Divide04P(void)
{
- Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
+ Vector4 v0(2.0f, 4.0f, 8.0f, 16.0f);
const Vector4 r0(20.0f, 40.0f, 80.0f, 160.0f);
- const Vector4 r1(10.0f, 20.0f, 40.0f, 80.0f);
- const Vector4 r2( 1.0f, 2.0f, 4.0f, 8.0f);
- const Vector4 r3(2.0f, 4.0f, 8.0f, 16.0f);
+ const Vector4 r1(10.0f, 20.0f, 40.0f, 80.0f);
+ const Vector4 r2(1.0f, 2.0f, 4.0f, 8.0f);
+ const Vector4 r3(2.0f, 4.0f, 8.0f, 16.0f);
Vector4 v2(r0);
v2 /= 10.0f;
int UtcDaliVector4NegateP(void)
{
TestApplication application;
- Vector4 v1(10.0f, 20.0f, 30.f, 40.f);
- Vector4 r0(-10.0f, -20.0f, -30.f, -40.f);
+ Vector4 v1(10.0f, 20.0f, 30.f, 40.f);
+ Vector4 r0(-10.0f, -20.0f, -30.f, -40.f);
Vector4 v2 = -v1;
DALI_TEST_EQUALS(v2, r0, TEST_LOCATION);
int UtcDaliVector4EqualsP(void)
{
- Vector4 v0(1.0f, 2.0f, 3.0f, 4.0f);
- Vector4 v1(1.0f, 2.0f, 3.0f, 4.0f);
+ Vector4 v0(1.0f, 2.0f, 3.0f, 4.0f);
+ Vector4 v1(1.0f, 2.0f, 3.0f, 4.0f);
DALI_TEST_CHECK(v0 == v1);
END_TEST;
int UtcDaliVector4NotEqualsP(void)
{
- Vector4 v0(1.0f, 2.0f, 3.0f, 4.0f);
- Vector4 v1(1.0f, 2.0f, 3.0f, 4.0f);
+ Vector4 v0(1.0f, 2.0f, 3.0f, 4.0f);
+ Vector4 v1(1.0f, 2.0f, 3.0f, 4.0f);
Vector4 v2 = Vector4(0.0f, 2.0f, 3.0f, 4.0f);
DALI_TEST_CHECK(v0 != v2);
Vector4 testVector(1.0f, 2.0f, 3.0f, 4.0f);
// read array subscripts
- DALI_TEST_EQUALS( testVector[0], 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[1], 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[2], 3.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[3], 4.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector[0], 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[1], 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[2], 3.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[3], 4.0f, TEST_LOCATION);
// write array subscripts/read struct memebers
testVector[0] = 5.0f;
testVector[2] = 7.0f;
testVector[3] = 8.0f;
- DALI_TEST_EQUALS( testVector.x, 5.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector.y, 6.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector.z, 7.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector.w, 8.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector.x, 5.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector.y, 6.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector.z, 7.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector.w, 8.0f, TEST_LOCATION);
// write struct members/read array subscripts
testVector.x = 9.0f;
testVector.z = 11.0f;
testVector.w = 12.0f;
- DALI_TEST_EQUALS( testVector[0], 9.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[1], 10.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[2], 11.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( testVector[3], 12.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(testVector[0], 9.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[1], 10.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[2], 11.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(testVector[3], 12.0f, TEST_LOCATION);
END_TEST;
}
-
int UtcDaliVector4ConstOperatorSubscriptP(void)
{
Vector4 testVector(1.0f, 2.0f, 3.0f, 4.0f);
// write struct members/read array subscripts
const Vector4 testVector2(1.0f, 2.0f, 3.0f, 4.0f);
- const float& x = testVector2[0];
- const float& y = testVector2[1];
- const float& z ( testVector2[2] );
- const float& w ( testVector2[3] );
+ const float& x = testVector2[0];
+ const float& y = testVector2[1];
+ const float& z(testVector2[2]);
+ const float& w(testVector2[3]);
- DALI_TEST_EQUALS( x, 1.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( y, 2.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( z, 3.0f, TEST_LOCATION );
- DALI_TEST_EQUALS( w, 4.0f, TEST_LOCATION );
+ DALI_TEST_EQUALS(x, 1.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(y, 2.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(z, 3.0f, TEST_LOCATION);
+ DALI_TEST_EQUALS(w, 4.0f, TEST_LOCATION);
try
{
(void)w; // Suppress unused variable warning
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "index < 4", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "index < 4", TEST_LOCATION);
}
try
(void)w; // Suppress unused variable warning
tet_result(TET_FAIL);
}
- catch (Dali::DaliException& e)
+ catch(Dali::DaliException& e)
{
- DALI_TEST_PRINT_ASSERT( e );
- DALI_TEST_ASSERT( e, "index < 4", TEST_LOCATION );
+ DALI_TEST_PRINT_ASSERT(e);
+ DALI_TEST_ASSERT(e, "index < 4", TEST_LOCATION);
}
END_TEST;
}
DALI_TEST_EQUALS(Vector4(1.0f, 0.0f, 0.0f, 1.0f).Dot(Vector4(1.0f, 0.0f, 0.0f, 1.0f)), 1.0f, TEST_LOCATION);
// Test v0 . v0 and v0 . v1 (v1 is always 90 degrees out of phase with v0)
- for (float x = 0; x<6.0f; x+=1.0f)
+ for(float x = 0; x < 6.0f; x += 1.0f)
{
// vectors rotating in the XY plane.
Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
DALI_TEST_EQUALS(Vector4(1.0f, 0.0f, 0.0f, 1.0f).Dot(Vector3(1.0f, 0.0f, 0.0f)), 1.0f, TEST_LOCATION);
// Test v0 . v0b and v0 . v1 (v1 is always 90 degrees out of phase with v0)
- for (float x = 0; x<6.0f; x+=1.0f)
+ for(float x = 0; x < 6.0f; x += 1.0f)
{
// vectors rotating in the XY plane.
Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
DALI_TEST_EQUALS(v0.Dot(v0b), 1.0f, 0.0001f, TEST_LOCATION);
// vectors rotating in the XZ plane.
- v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
+ v0 = Vector4(cosf(x), 0.0f, sinf(x), 0.0f);
v0b = Vector3(cosf(x), 0.0f, sinf(x));
- v1 = Vector3(sinf(x), 0.0f, -cosf(x));
+ v1 = Vector3(sinf(x), 0.0f, -cosf(x));
DALI_TEST_EQUALS(v0.Dot(v1), 0.0f, 0.0001f, TEST_LOCATION);
DALI_TEST_EQUALS(v0.Dot(v0b), 1.0f, 0.0001f, TEST_LOCATION);
}
DALI_TEST_EQUALS(Vector4(1.0f, 0.0f, 0.0f, 1.0f).Dot4(Vector4(1.0f, 0.0f, 0.0f, 1.0f)), 2.0f, TEST_LOCATION);
- for (float x = 0; x<6.0f; x+=1.0f)
+ for(float x = 0; x < 6.0f; x += 1.0f)
{
Vector4 v0(cosf(x), sinf(x), 0.0f, 1.0f);
Vector4 v1(sinf(x), -cosf(x), 0.0f, 1.0f);
v0.Normalize();
Vector4 v1 = v0 * 2.0f;
- DALI_TEST_EQUALS(v0.Dot4(v1), 2.0f + 3.0f*6.0f, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v0.Dot4(v1), 2.0f + 3.0f * 6.0f, 0.001f, TEST_LOCATION);
END_TEST;
}
Vector4 v0(2.0f, 3.0f, 4.0f, 5.0f);
Vector4 v1(10.0f, 20.0f, 30.0f, 40.0f);
- Vector4 result( (v0.y * v1.z) - (v0.z * v1.y),
- (v0.z * v1.x) - (v0.x * v1.z),
- (v0.x * v1.y) - (v0.y * v1.x),
- 0.0f);
+ Vector4 result((v0.y * v1.z) - (v0.z * v1.y),
+ (v0.z * v1.x) - (v0.x * v1.z),
+ (v0.x * v1.y) - (v0.y * v1.x),
+ 0.0f);
DALI_TEST_EQUALS(v0.Cross(v1), result, 0.001f, TEST_LOCATION);
END_TEST;
int UtcDaliVector4LengthP(void)
{
Vector4 v(1.0f, 2.0f, 3.0f, 4.0f);
- DALI_TEST_EQUALS(v.Length(), sqrtf(v.x*v.x + v.y*v.y + v.z*v.z), 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.Length(), sqrtf(v.x * v.x + v.y * v.y + v.z * v.z), 0.001f, TEST_LOCATION);
Vector4 v1(0.0f, 0.0f, 0.0f, 0.0f);
DALI_TEST_EQUALS(v1.Length(), 0.0f, TEST_LOCATION);
int UtcDaliVector4LengthSquaredP(void)
{
Vector4 v(1.0f, 2.0f, 3.0f, 4.0f);
- DALI_TEST_EQUALS(v.LengthSquared(), v.x*v.x + v.y*v.y + v.z*v.z, 0.001f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v.LengthSquared(), v.x * v.x + v.y * v.y + v.z * v.z, 0.001f, TEST_LOCATION);
Vector4 v1(0.0f, 0.0f, 0.0f, 0.0f);
DALI_TEST_EQUALS(v1.LengthSquared(), 0.0f, TEST_LOCATION);
int UtcDaliVector4NormalizeP(void)
{
- for (float f=0.0f; f<6.0f; f+=1.0f)
+ for(float f = 0.0f; f < 6.0f; f += 1.0f)
{
- Vector4 v(cosf(f)*10.0f, cosf(f+1.0f)*10.0f, cosf(f+2.0f)*10.0f, 1.0f);
+ Vector4 v(cosf(f) * 10.0f, cosf(f + 1.0f) * 10.0f, cosf(f + 2.0f) * 10.0f, 1.0f);
v.Normalize();
DALI_TEST_EQUALS(v.LengthSquared(), 1.0f, 0.001f, TEST_LOCATION);
}
Vector4 min(1.0f, -2.0f, -8.0f, -16.0f);
Vector4 max(2.0f, 4.0f, 4.0f, -8.0f);
- v0.Clamp( min, max );
- v1.Clamp( min, max );
- v2.Clamp( min, max );
- v3.Clamp( min, max );
- v4.Clamp( min, max );
+ v0.Clamp(min, max);
+ v1.Clamp(min, max);
+ v2.Clamp(min, max);
+ v3.Clamp(min, max);
+ v4.Clamp(min, max);
- DALI_TEST_EQUALS( v0, Vector4( 2.0f, 0.8f, 0.0f, -8.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v1, Vector4( 1.0f, 2.0f, 4.0f, -10.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v2, Vector4( 2.0f, 4.0f, 0.0f, -8.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v3, Vector4( 2.0f, 4.0f, 4.0f, -16.0f), 0.01f, TEST_LOCATION );
- DALI_TEST_EQUALS( v4, Vector4( 2.0f, 4.0f, 4.0f, -8.0f), 0.01f, TEST_LOCATION );
+ DALI_TEST_EQUALS(v0, Vector4(2.0f, 0.8f, 0.0f, -8.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v1, Vector4(1.0f, 2.0f, 4.0f, -10.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v2, Vector4(2.0f, 4.0f, 0.0f, -8.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v3, Vector4(2.0f, 4.0f, 4.0f, -16.0f), 0.01f, TEST_LOCATION);
+ DALI_TEST_EQUALS(v4, Vector4(2.0f, 4.0f, 4.0f, -8.0f), 0.01f, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector4AsFloatP(void)
{
- float values[] = {0.0f, 1.0f, 2.0f, 3.0f};
+ float values[] = {0.0f, 1.0f, 2.0f, 3.0f};
Vector4 v0(values);
- for (int i=0;i<4;++i)
+ for(int i = 0; i < 4; ++i)
{
DALI_TEST_EQUALS(v0.AsFloat()[i], values[i], TEST_LOCATION);
}
int UtcDaliVector4ConstAsFloatP(void)
{
- float values[] = {0.0f, 1.0f, 2.0f, 3.0f};
+ float values[] = {0.0f, 1.0f, 2.0f, 3.0f};
Vector4 v0(values);
const Vector4 v1(values);
- for (int i=0;i<4;++i)
+ for(int i = 0; i < 4; ++i)
{
DALI_TEST_EQUALS(v1.AsFloat()[i], values[i], TEST_LOCATION);
}
std::string expectedOutput = "[1, 2, 3, 4]";
- DALI_TEST_EQUALS( oss.str(), expectedOutput, TEST_LOCATION);
+ DALI_TEST_EQUALS(oss.str(), expectedOutput, TEST_LOCATION);
END_TEST;
}
int UtcDaliVector4ConstantsP(void)
{
- float f[] = {2.0f, 3.0f, 4.0f, 5.0f};
+ float f[] = {2.0f, 3.0f, 4.0f, 5.0f};
Vector4 v0(f);
Vector4 v1(f[0], f[1], f[2], f[3]);
Vector4 v2(v0);
*
*/
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
using namespace Dali;
TestApplication application;
Property::Map texturedQuadVertexFormat;
- texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
+ texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
texturedQuadVertexFormat["aVertexCoord"] = Property::VECTOR2;
- VertexBuffer vertexBuffer = VertexBuffer::New( texturedQuadVertexFormat );
+ VertexBuffer vertexBuffer = VertexBuffer::New(texturedQuadVertexFormat);
- DALI_TEST_EQUALS( (bool)vertexBuffer, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)vertexBuffer, true, TEST_LOCATION);
END_TEST;
}
int UtcDaliVertexBufferNew02(void)
{
TestApplication application;
- VertexBuffer vertexBuffer;
- DALI_TEST_EQUALS( (bool)vertexBuffer, false, TEST_LOCATION );
+ VertexBuffer vertexBuffer;
+ DALI_TEST_EQUALS((bool)vertexBuffer, false, TEST_LOCATION);
END_TEST;
}
TestApplication application;
Property::Map texturedQuadVertexFormat;
- texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
+ texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
texturedQuadVertexFormat["aVertexCoord"] = Property::VECTOR2;
- VertexBuffer vertexBuffer = VertexBuffer::New( texturedQuadVertexFormat );
+ VertexBuffer vertexBuffer = VertexBuffer::New(texturedQuadVertexFormat);
- BaseHandle handle(vertexBuffer);
+ BaseHandle handle(vertexBuffer);
VertexBuffer vertexBuffer2 = VertexBuffer::DownCast(handle);
- DALI_TEST_EQUALS( (bool)vertexBuffer2, true, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)vertexBuffer2, true, TEST_LOCATION);
END_TEST;
}
{
TestApplication application;
- Handle handle = Handle::New(); // Create a custom object
+ Handle handle = Handle::New(); // Create a custom object
VertexBuffer vertexBuffer = VertexBuffer::DownCast(handle);
- DALI_TEST_EQUALS( (bool)vertexBuffer, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)vertexBuffer, false, TEST_LOCATION);
END_TEST;
}
VertexBuffer vertexBufferCopy(vertexBuffer);
- DALI_TEST_EQUALS( (bool)vertexBufferCopy, true, TEST_LOCATION );
- DALI_TEST_EQUALS( vertexBufferCopy.GetSize(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)vertexBufferCopy, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(vertexBufferCopy.GetSize(), 0u, TEST_LOCATION);
END_TEST;
}
VertexBuffer vertexBuffer = CreateVertexBuffer();
VertexBuffer vertexBuffer2;
- DALI_TEST_EQUALS( (bool)vertexBuffer2, false, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)vertexBuffer2, false, TEST_LOCATION);
vertexBuffer2 = vertexBuffer;
- DALI_TEST_EQUALS( (bool)vertexBuffer2, true, TEST_LOCATION );
- DALI_TEST_EQUALS( vertexBuffer2.GetSize(), 0u, TEST_LOCATION );
+ DALI_TEST_EQUALS((bool)vertexBuffer2, true, TEST_LOCATION);
+ DALI_TEST_EQUALS(vertexBuffer2.GetSize(), 0u, TEST_LOCATION);
END_TEST;
}
TestApplication application;
VertexBuffer vertexBuffer = CreateVertexBuffer();
- DALI_TEST_CHECK( vertexBuffer );
- DALI_TEST_EQUALS( 1, vertexBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, vertexBuffer.GetSize(), TEST_LOCATION );
+ DALI_TEST_CHECK(vertexBuffer);
+ DALI_TEST_EQUALS(1, vertexBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, vertexBuffer.GetSize(), TEST_LOCATION);
- VertexBuffer move = std::move( vertexBuffer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, move.GetSize(), TEST_LOCATION );
- DALI_TEST_CHECK( !vertexBuffer );
+ VertexBuffer move = std::move(vertexBuffer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, move.GetSize(), TEST_LOCATION);
+ DALI_TEST_CHECK(!vertexBuffer);
END_TEST;
}
TestApplication application;
VertexBuffer vertexBuffer = CreateVertexBuffer();
- DALI_TEST_CHECK( vertexBuffer );
- DALI_TEST_EQUALS( 1, vertexBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, vertexBuffer.GetSize(), TEST_LOCATION );
+ DALI_TEST_CHECK(vertexBuffer);
+ DALI_TEST_EQUALS(1, vertexBuffer.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, vertexBuffer.GetSize(), TEST_LOCATION);
VertexBuffer move;
- move = std::move( vertexBuffer );
- DALI_TEST_CHECK( move );
- DALI_TEST_EQUALS( 1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION );
- DALI_TEST_EQUALS( 0u, move.GetSize(), TEST_LOCATION );
- DALI_TEST_CHECK( !vertexBuffer );
+ move = std::move(vertexBuffer);
+ DALI_TEST_CHECK(move);
+ DALI_TEST_EQUALS(1, move.GetBaseObject().ReferenceCount(), TEST_LOCATION);
+ DALI_TEST_EQUALS(0u, move.GetSize(), TEST_LOCATION);
+ DALI_TEST_CHECK(!vertexBuffer);
END_TEST;
}
TestApplication application;
Property::Map texturedQuadVertexFormat;
- texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
+ texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
texturedQuadVertexFormat["aVertexCoord"] = Property::VECTOR2;
{
- VertexBuffer vertexBuffer = VertexBuffer::New( texturedQuadVertexFormat );
- DALI_TEST_EQUALS( (bool)vertexBuffer, true, TEST_LOCATION );
+ VertexBuffer vertexBuffer = VertexBuffer::New(texturedQuadVertexFormat);
+ DALI_TEST_EQUALS((bool)vertexBuffer, true, TEST_LOCATION);
const float halfQuadSize = .5f;
- struct TexturedQuadVertex { Vector2 position; Vector2 textureCoordinates; };
+ struct TexturedQuadVertex
+ {
+ Vector2 position;
+ Vector2 textureCoordinates;
+ };
TexturedQuadVertex texturedQuadVertexData[4] = {
- { Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f) },
- { Vector2( halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f) },
- { Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f) },
- { Vector2( halfQuadSize, halfQuadSize), Vector2(1.f, 1.f) } };
+ {Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f)},
+ {Vector2(halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f)},
+ {Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f)},
+ {Vector2(halfQuadSize, halfQuadSize), Vector2(1.f, 1.f)}};
- vertexBuffer.SetData( texturedQuadVertexData, 4 );
+ vertexBuffer.SetData(texturedQuadVertexData, 4);
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
+ geometry.AddVertexBuffer(vertexBuffer);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
application.SendNotification();
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
- application.GetGlAbstraction().GetBufferDataCalls();
-
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
+ application.GetGlAbstraction().GetBufferDataCalls();
- DALI_TEST_EQUALS( bufferDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(bufferDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION);
}
// end of scope to let the buffer and geometry die; do another notification and render to get the deletion processed
application.SendNotification();
TestApplication application;
Property::Map texturedQuadVertexFormat;
- texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
+ texturedQuadVertexFormat["aPosition"] = Property::VECTOR2;
texturedQuadVertexFormat["aVertexCoord"] = Property::VECTOR2;
- VertexBuffer vertexBuffer = VertexBuffer::New( texturedQuadVertexFormat );
- DALI_TEST_EQUALS( (bool)vertexBuffer, true, TEST_LOCATION );
+ VertexBuffer vertexBuffer = VertexBuffer::New(texturedQuadVertexFormat);
+ DALI_TEST_EQUALS((bool)vertexBuffer, true, TEST_LOCATION);
const float halfQuadSize = .5f;
- struct TexturedQuadVertex { Vector2 position; Vector2 textureCoordinates; };
+ struct TexturedQuadVertex
+ {
+ Vector2 position;
+ Vector2 textureCoordinates;
+ };
TexturedQuadVertex texturedQuadVertexData[4] = {
- { Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f) },
- { Vector2( halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f) },
- { Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f) },
- { Vector2( halfQuadSize, halfQuadSize), Vector2(1.f, 1.f) } };
+ {Vector2(-halfQuadSize, -halfQuadSize), Vector2(0.f, 0.f)},
+ {Vector2(halfQuadSize, -halfQuadSize), Vector2(1.f, 0.f)},
+ {Vector2(-halfQuadSize, halfQuadSize), Vector2(0.f, 1.f)},
+ {Vector2(halfQuadSize, halfQuadSize), Vector2(1.f, 1.f)}};
- vertexBuffer.SetData( texturedQuadVertexData, 4 );
+ vertexBuffer.SetData(texturedQuadVertexData, 4);
Geometry geometry = Geometry::New();
- geometry.AddVertexBuffer( vertexBuffer );
+ geometry.AddVertexBuffer(vertexBuffer);
- Shader shader = CreateShader();
+ Shader shader = CreateShader();
Renderer renderer = Renderer::New(geometry, shader);
- Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE,Vector3::ONE * 100.f);
+ Actor actor = Actor::New();
+ actor.SetProperty(Actor::Property::SIZE, Vector3::ONE * 100.f);
actor.AddRenderer(renderer);
application.GetScene().Add(actor);
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
application.GetGlAbstraction().GetBufferDataCalls();
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
- DALI_TEST_EQUALS( bufferDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION);
}
// Re-upload the data on the vertexBuffer
- vertexBuffer.SetData( texturedQuadVertexData, 4 );
+ vertexBuffer.SetData(texturedQuadVertexData, 4);
application.SendNotification();
application.Render(0);
application.GetGlAbstraction().GetBufferSubDataCalls();
const TestGlAbstraction::BufferDataCalls& bufferDataCalls =
- application.GetGlAbstraction().GetBufferDataCalls();
+ application.GetGlAbstraction().GetBufferDataCalls();
- DALI_TEST_EQUALS( bufferSubDataCalls.size(), 1u, TEST_LOCATION );
- DALI_TEST_EQUALS( bufferDataCalls.size(), 1u, TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferSubDataCalls.size(), 1u, TEST_LOCATION);
+ DALI_TEST_EQUALS(bufferDataCalls.size(), 1u, TEST_LOCATION);
- if ( bufferSubDataCalls.size() )
+ if(bufferSubDataCalls.size())
{
- DALI_TEST_EQUALS( bufferSubDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION );
+ DALI_TEST_EQUALS(bufferSubDataCalls[0], sizeof(texturedQuadVertexData), TEST_LOCATION);
}
}
TestApplication application;
Property::Map texturedQuadVertexFormat;
- texturedQuadVertexFormat["aPosition"] = Property::MAP;
+ texturedQuadVertexFormat["aPosition"] = Property::MAP;
texturedQuadVertexFormat["aVertexCoord"] = Property::STRING;
try
{
- VertexBuffer vertexBuffer = VertexBuffer::New( texturedQuadVertexFormat );
+ VertexBuffer vertexBuffer = VertexBuffer::New(texturedQuadVertexFormat);
tet_result(TET_FAIL);
}
- catch ( Dali::DaliException& e )
+ catch(Dali::DaliException& e)
{
- DALI_TEST_ASSERT( e, "Property::Type not supported in VertexBuffer", TEST_LOCATION );
+ DALI_TEST_ASSERT(e, "Property::Type not supported in VertexBuffer", TEST_LOCATION);
}
END_TEST;
}
-
int UtcDaliVertexBufferSetDataNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::VertexBuffer instance;
try
{
- void* arg1(nullptr);
+ void* arg1(nullptr);
unsigned long arg2(0u);
- instance.SetData(arg1,arg2);
+ instance.SetData(arg1, arg2);
DALI_TEST_CHECK(false); // Should not get here
}
catch(...)
int UtcDaliVertexBufferGetSizeNegative(void)
{
- TestApplication application;
+ TestApplication application;
Dali::VertexBuffer instance;
try
{
*
*/
-#include <dali/public-api/dali-core.h>
#include <dali-test-suite-utils.h>
+#include <dali/public-api/dali-core.h>
using namespace Dali;
namespace
{
-
/*******************************************************************************
*
* Custom Actor
{
struct MyTestCustomActor : public CustomActorImpl
{
- typedef Signal< void ()> SignalType;
- typedef Signal< void (float)> SignalTypeFloat;
+ typedef Signal<void()> SignalType;
+ typedef Signal<void(float)> SignalTypeFloat;
- MyTestCustomActor() : CustomActorImpl( ActorFlags() )
- { }
+ MyTestCustomActor()
+ : CustomActorImpl(ActorFlags())
+ {
+ }
virtual ~MyTestCustomActor()
- { }
+ {
+ }
void ResetCallStack()
{
}
// From CustomActorImpl
- virtual void OnSceneConnection( int depth )
+ virtual void OnSceneConnection(int depth)
{
}
virtual void OnSceneDisconnection()
}
virtual Vector3 GetNaturalSize()
{
- return Vector3( 0.0f, 0.0f, 0.0f );
+ return Vector3(0.0f, 0.0f, 0.0f);
}
- virtual float GetHeightForWidth( float width )
+ virtual float GetHeightForWidth(float width)
{
return 0.0f;
}
- virtual float GetWidthForHeight( float height )
+ virtual float GetWidthForHeight(float height)
{
return 0.0f;
}
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
+ virtual void OnRelayout(const Vector2& size, RelayoutContainer& container)
{
}
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+ virtual void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
{
}
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
+ virtual void OnCalculateRelayoutSize(Dimension::Type dimension)
{
}
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+ virtual float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension)
{
return 0.0f;
}
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
+ virtual void OnLayoutNegotiated(float size, Dimension::Type dimension)
{
}
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
+ virtual bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS)
{
return false;
}
public:
-
SignalType mSignal;
};
class MyTestCustomActor : public CustomActor
{
public:
-
- typedef Signal< void ()> SignalType;
- typedef Signal< void (float)> SignalTypeFloat;
+ typedef Signal<void()> SignalType;
+ typedef Signal<void(float)> SignalTypeFloat;
MyTestCustomActor()
{
static MyTestCustomActor New()
{
Impl::MyTestCustomActor* p = new Impl::MyTestCustomActor;
- return MyTestCustomActor( *p ); // takes ownership
+ return MyTestCustomActor(*p); // takes ownership
}
virtual ~MyTestCustomActor()
{
}
- static MyTestCustomActor DownCast( BaseHandle handle )
+ static MyTestCustomActor DownCast(BaseHandle handle)
{
MyTestCustomActor result;
- CustomActor custom = Dali::CustomActor::DownCast( handle );
- if ( custom )
+ CustomActor custom = Dali::CustomActor::DownCast(handle);
+ if(custom)
{
CustomActorImpl& customImpl = custom.GetImplementation();
Impl::MyTestCustomActor* impl = dynamic_cast<Impl::MyTestCustomActor*>(&customImpl);
- if (impl)
+ if(impl)
{
result = MyTestCustomActor(customImpl.GetOwner());
}
SignalType& GetCustomSignal()
{
Dali::RefObject& obj = GetImplementation();
- return static_cast<Impl::MyTestCustomActor&>( obj ).mSignal;
+ return static_cast<Impl::MyTestCustomActor&>(obj).mSignal;
}
MyTestCustomActor(Internal::CustomActor* internal)
{
}
- MyTestCustomActor( Impl::MyTestCustomActor& impl )
- : CustomActor( impl )
+ MyTestCustomActor(Impl::MyTestCustomActor& impl)
+ : CustomActor(impl)
{
}
};
-}
+} // namespace
int UtcDaliWeakHandleBaseConstructorVoid(void)
{
TestApplication application;
tet_infoline("Testing Dali::WeakHandleBase::WeakHandleBase(BaseHandle)");
- BaseHandle emptyHandle;
+ BaseHandle emptyHandle;
WeakHandleBase emptyObject(emptyHandle);
DALI_TEST_CHECK(!emptyObject.GetBaseHandle());
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
WeakHandleBase object(actor);
DALI_TEST_CHECK(object.GetBaseHandle() == actor);
- Animation animation = Animation::New( 1.0f );
- WeakHandleBase animationObject( animation );
- DALI_TEST_CHECK( animationObject.GetBaseHandle() == animation );
+ Animation animation = Animation::New(1.0f);
+ WeakHandleBase animationObject(animation);
+ DALI_TEST_CHECK(animationObject.GetBaseHandle() == animation);
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
- WeakHandleBase object( actor );
- DALI_TEST_CHECK( object.GetBaseHandle() == actor);
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ WeakHandleBase object(actor);
+ DALI_TEST_CHECK(object.GetBaseHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
- WeakHandleBase move = std::move( object );
- DALI_TEST_CHECK(move.GetBaseHandle() == actor );
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
- DALI_TEST_CHECK( !object.GetBaseHandle() ); // object moved
+ WeakHandleBase move = std::move(object);
+ DALI_TEST_CHECK(move.GetBaseHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
+ DALI_TEST_CHECK(!object.GetBaseHandle()); // object moved
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
- WeakHandleBase object( actor );
- DALI_TEST_CHECK( object.GetBaseHandle() == actor);
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ WeakHandleBase object(actor);
+ DALI_TEST_CHECK(object.GetBaseHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
WeakHandleBase move;
- move = std::move( object );
- DALI_TEST_CHECK(move.GetBaseHandle() == actor );
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
- DALI_TEST_CHECK( !object.GetBaseHandle() ); // object moved
+ move = std::move(object);
+ DALI_TEST_CHECK(move.GetBaseHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
+ DALI_TEST_CHECK(!object.GetBaseHandle()); // object moved
END_TEST;
}
WeakHandleBase object(actor);
DALI_TEST_CHECK(object.GetBaseHandle() == actor);
- Actor differentActor = Actor::New();
+ Actor differentActor = Actor::New();
WeakHandleBase aDifferentWeakHandleBase(differentActor);
DALI_TEST_CHECK(!(object == aDifferentWeakHandleBase));
WeakHandleBase object(actor);
DALI_TEST_CHECK(object.GetBaseHandle() == actor);
- Actor differentActor = Actor::New();
+ Actor differentActor = Actor::New();
WeakHandleBase aDifferentWeakHandleBase(differentActor);
DALI_TEST_CHECK(object != aDifferentWeakHandleBase);
TestApplication application;
tet_infoline("Testing Dali::WeakHandleBase::GetBaseHandle()");
- Handle emptyHandle;
+ Handle emptyHandle;
WeakHandleBase emptyObject(emptyHandle);
DALI_TEST_CHECK(!emptyObject.GetBaseHandle());
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
WeakHandleBase object(actor);
DALI_TEST_CHECK(object.GetBaseHandle() == actor);
WeakHandleBase theSameObject = WeakHandleBase(actor);
DALI_TEST_CHECK(object.GetBaseHandle() == theSameObject.GetBaseHandle());
- Actor differentActor = Actor::New();
+ Actor differentActor = Actor::New();
WeakHandleBase aDifferentWeakHandleBase(differentActor);
DALI_TEST_CHECK(object.GetBaseHandle() != aDifferentWeakHandleBase.GetBaseHandle());
- Animation animation = Animation::New( 1.0f );
- WeakHandleBase animationObject( animation );
- DALI_TEST_CHECK( animationObject.GetBaseHandle() == animation );
+ Animation animation = Animation::New(1.0f);
+ WeakHandleBase animationObject(animation);
+ DALI_TEST_CHECK(animationObject.GetBaseHandle() == animation);
- WeakHandleBase theSameAnimationObject = WeakHandleBase( animation );
- DALI_TEST_CHECK( animationObject.GetBaseHandle() == theSameAnimationObject.GetBaseHandle() );
+ WeakHandleBase theSameAnimationObject = WeakHandleBase(animation);
+ DALI_TEST_CHECK(animationObject.GetBaseHandle() == theSameAnimationObject.GetBaseHandle());
- Animation differentAnimation = Animation::New( 1.0f );
- WeakHandleBase aDifferentAnimationObject( differentAnimation );
- DALI_TEST_CHECK( animationObject.GetBaseHandle() != aDifferentAnimationObject.GetBaseHandle() );
+ Animation differentAnimation = Animation::New(1.0f);
+ WeakHandleBase aDifferentAnimationObject(differentAnimation);
+ DALI_TEST_CHECK(animationObject.GetBaseHandle() != aDifferentAnimationObject.GetBaseHandle());
END_TEST;
}
int UtcDaliWeakHandleBaseReset(void)
{
TestApplication application;
- tet_infoline( "Testing Daku::WeakHandleBase::Reset()" );
+ tet_infoline("Testing Daku::WeakHandleBase::Reset()");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
WeakHandleBase object(actor);
DALI_TEST_CHECK(object.GetBaseHandle() == actor);
TestApplication application;
tet_infoline("Testing Dali::WeakHandle::GetHandle()");
- Actor actor = Actor::New();
+ Actor actor = Actor::New();
WeakHandle<Actor> object(actor);
DALI_TEST_CHECK(object.GetHandle() == actor);
- MyTestCustomActor customActor = MyTestCustomActor::New();
+ MyTestCustomActor customActor = MyTestCustomActor::New();
WeakHandle<MyTestCustomActor> customObject(customActor);
DALI_TEST_CHECK(customObject.GetHandle() == customActor);
DALI_TEST_CHECK(object.GetHandle() != customObject.GetHandle());
- Animation animation = Animation::New( 1.0f );
- WeakHandle<Animation> animationObject( animation );
- DALI_TEST_CHECK( animationObject.GetHandle() == animation );
+ Animation animation = Animation::New(1.0f);
+ WeakHandle<Animation> animationObject(animation);
+ DALI_TEST_CHECK(animationObject.GetHandle() == animation);
animation.Reset();
- DALI_TEST_CHECK( animationObject.GetHandle() == Animation() );
+ DALI_TEST_CHECK(animationObject.GetHandle() == Animation());
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
- WeakHandle<Actor> object( actor );
- DALI_TEST_CHECK( object.GetHandle() == actor );
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ WeakHandle<Actor> object(actor);
+ DALI_TEST_CHECK(object.GetHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
- WeakHandle<Actor> move = std::move( object );
- DALI_TEST_CHECK( move.GetHandle() == actor );
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
- DALI_TEST_CHECK( !object.GetHandle() ); // object moved
+ WeakHandle<Actor> move = std::move(object);
+ DALI_TEST_CHECK(move.GetHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
+ DALI_TEST_CHECK(!object.GetHandle()); // object moved
END_TEST;
}
TestApplication application;
Actor actor = Actor::New();
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
- WeakHandle<Actor> object( actor );
- DALI_TEST_CHECK( object.GetHandle() == actor );
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
+ WeakHandle<Actor> object(actor);
+ DALI_TEST_CHECK(object.GetHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
WeakHandle<Actor> move;
- move = std::move( object );
- DALI_TEST_CHECK( move.GetHandle() == actor );
- DALI_TEST_EQUALS( 1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION ); // reference count of the actor is not increased
- DALI_TEST_CHECK( !object.GetHandle() ); // object moved
+ move = std::move(object);
+ DALI_TEST_CHECK(move.GetHandle() == actor);
+ DALI_TEST_EQUALS(1, actor.GetBaseObject().ReferenceCount(), TEST_LOCATION); // reference count of the actor is not increased
+ DALI_TEST_CHECK(!object.GetHandle()); // object moved
END_TEST;
}
*
*/
-#include <iostream>
-#include <stdlib.h>
-#include <dali/public-api/dali-core.h>
-#include <dali/integration-api/events/wheel-event-integ.h>
-#include <dali/devel-api/events/wheel-event-devel.h>
#include <dali-test-suite-utils.h>
+#include <dali/devel-api/events/wheel-event-devel.h>
+#include <dali/integration-api/events/wheel-event-integ.h>
+#include <dali/public-api/dali-core.h>
+#include <stdlib.h>
+
+#include <iostream>
using namespace Dali;
namespace
{
-
// Key Event Test references
-const static unsigned int SHIFT_MODIFIER = 0x1;
-const static unsigned int CTRL_MODIFIER = 0x2;
-const static unsigned int ALT_MODIFIER = 0x4;
-const static unsigned int SHIFT_AND_CTRL_MODIFIER = SHIFT_MODIFIER | CTRL_MODIFIER;
-
+const static unsigned int SHIFT_MODIFIER = 0x1;
+const static unsigned int CTRL_MODIFIER = 0x2;
+const static unsigned int ALT_MODIFIER = 0x4;
+const static unsigned int SHIFT_AND_CTRL_MODIFIER = SHIFT_MODIFIER | CTRL_MODIFIER;
// Stores data that is populated in the callback and will be read by the TET cases
struct SignalData
{
SignalData()
: functorCalled(false)
- {}
+ {
+ }
void Reset()
{
wheeledActor.Reset();
}
- bool functorCalled;
+ bool functorCalled;
WheelEvent receivedWheelEvent;
- Actor wheeledActor;
+ Actor wheeledActor;
};
// Functor that sets the data when called
struct WheelEventReceivedFunctor
{
- WheelEventReceivedFunctor( SignalData& data ) : signalData( data ) { }
+ WheelEventReceivedFunctor(SignalData& data)
+ : signalData(data)
+ {
+ }
- bool operator()( Actor actor, const WheelEvent& wheelEvent )
+ bool operator()(Actor actor, const WheelEvent& wheelEvent)
{
- signalData.functorCalled = true;
+ signalData.functorCalled = true;
signalData.receivedWheelEvent = wheelEvent;
- signalData.wheeledActor = actor;
+ signalData.wheeledActor = actor;
return true;
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(Dali::WheelEvent::MOUSE_WHEEL, event.GetType(), TEST_LOCATION); // check type
- DALI_TEST_EQUALS(1, event.GetDirection(), TEST_LOCATION); // check direction
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(Vector2(1.0f, 1.0f), event.GetPoint(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(1, event.GetDelta(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(1000u, event.GetTime(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1, event.GetDirection(), TEST_LOCATION); // check direction
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(Vector2(1.0f, 1.0f), event.GetPoint(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1, event.GetDelta(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1000u, event.GetTime(), TEST_LOCATION); // check modifier
END_TEST;
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetModifiers(), TEST_LOCATION);
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, CTRL_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, CTRL_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetModifiers(), TEST_LOCATION);
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, ALT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, ALT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(ALT_MODIFIER, event.GetModifiers(), TEST_LOCATION);
- DALI_TEST_EQUALS(true, event.IsAltModifier(), TEST_LOCATION); // IsAltModifier
+ DALI_TEST_EQUALS(true, event.IsAltModifier(), TEST_LOCATION); // IsAltModifier
END_TEST;
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, CTRL_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, CTRL_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
- DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check different modifier used
+ DALI_TEST_EQUALS(CTRL_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check different modifier used
DALI_TEST_EQUALS(false, event.IsShiftModifier(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, ALT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, ALT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
- DALI_TEST_EQUALS(ALT_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check different modifier used
+ DALI_TEST_EQUALS(ALT_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check different modifier used
DALI_TEST_EQUALS(false, event.IsCtrlModifier(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
- DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check different modifier used
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, event.GetModifiers(), TEST_LOCATION); // check different modifier used
DALI_TEST_EQUALS(false, event.IsAltModifier(), TEST_LOCATION);
END_TEST;
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_AND_CTRL_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_AND_CTRL_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(true, event.IsCtrlModifier() && event.IsShiftModifier(), TEST_LOCATION);
- Dali::WheelEvent newEvent = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
+ Dali::WheelEvent newEvent = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
DALI_TEST_EQUALS(false, newEvent.IsCtrlModifier() && newEvent.IsShiftModifier(), TEST_LOCATION);
END_TEST;
}
{
TestApplication application; // Reset all test adapter return codes
- Dali::WheelEvent event = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_AND_CTRL_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
- DALI_TEST_CHECK( event );
+ Dali::WheelEvent event = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_AND_CTRL_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
+ DALI_TEST_CHECK(event);
DALI_TEST_EQUALS(true, event.IsCtrlModifier() || event.IsAltModifier(), TEST_LOCATION);
- Dali::WheelEvent newEvent = DevelWheelEvent::New( Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2( 1.0f, 1.0f ), 1, 1000u );
+ Dali::WheelEvent newEvent = DevelWheelEvent::New(Dali::WheelEvent::MOUSE_WHEEL, 1, SHIFT_MODIFIER, Vector2(1.0f, 1.0f), 1, 1000u);
DALI_TEST_EQUALS(false, newEvent.IsCtrlModifier() && newEvent.IsAltModifier(), TEST_LOCATION);
END_TEST;
}
TestApplication application; // Reset all test adapter return codes
Actor actor = Actor::New();
- actor.SetProperty( Actor::Property::SIZE, Vector2( 100.0f, 100.0f ) );
- actor.SetProperty( Actor::Property::ANCHOR_POINT,AnchorPoint::TOP_LEFT);
+ actor.SetProperty(Actor::Property::SIZE, Vector2(100.0f, 100.0f));
+ actor.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
application.GetScene().Add(actor);
// Render and notify
application.Render();
// Connect to actor's wheel event signal
- SignalData data;
- WheelEventReceivedFunctor functor( data );
- actor.WheelEventSignal().Connect( &application, functor );
+ SignalData data;
+ WheelEventReceivedFunctor functor(data);
+ actor.WheelEventSignal().Connect(&application, functor);
- Vector2 screenCoordinates( 10.0f, 10.0f );
+ Vector2 screenCoordinates(10.0f, 10.0f);
Integration::WheelEvent event(Integration::WheelEvent::MOUSE_WHEEL, 0, SHIFT_MODIFIER, screenCoordinates, 1, 1000u);
// Emit a wheel signal
- application.ProcessEvent( event );
- DALI_TEST_EQUALS( true, data.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( actor == data.wheeledActor );
+ application.ProcessEvent(event);
+ DALI_TEST_EQUALS(true, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(actor == data.wheeledActor);
DALI_TEST_EQUALS(WheelEvent::MOUSE_WHEEL, data.receivedWheelEvent.GetType(), TEST_LOCATION); // check type
- DALI_TEST_EQUALS(0, data.receivedWheelEvent.GetDirection(), TEST_LOCATION); // check direction
- DALI_TEST_EQUALS(SHIFT_MODIFIER, data.receivedWheelEvent.GetModifiers(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(screenCoordinates, data.receivedWheelEvent.GetPoint(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(1, data.receivedWheelEvent.GetDelta(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(1000u, data.receivedWheelEvent.GetTime(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0, data.receivedWheelEvent.GetDirection(), TEST_LOCATION); // check direction
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, data.receivedWheelEvent.GetModifiers(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(screenCoordinates, data.receivedWheelEvent.GetPoint(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1, data.receivedWheelEvent.GetDelta(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1000u, data.receivedWheelEvent.GetTime(), TEST_LOCATION); // check modifier
data.Reset();
// Emit a wheel signal where the actor is not present, will hit the root actor though
- Actor rootActor( application.GetScene().GetRootLayer() );
+ Actor rootActor(application.GetScene().GetRootLayer());
// Connect to root actor's wheel event signal
- SignalData rootData;
- WheelEventReceivedFunctor rootFunctor( rootData ); // Consumes signal
- rootActor.WheelEventSignal().Connect( &application, rootFunctor );
+ SignalData rootData;
+ WheelEventReceivedFunctor rootFunctor(rootData); // Consumes signal
+ rootActor.WheelEventSignal().Connect(&application, rootFunctor);
screenCoordinates.x = screenCoordinates.y = 300.0f;
Integration::WheelEvent newEvent(Integration::WheelEvent::MOUSE_WHEEL, 0, SHIFT_MODIFIER, screenCoordinates, 1, 1000u);
- application.ProcessEvent( newEvent );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
- DALI_TEST_EQUALS( true, rootData.functorCalled, TEST_LOCATION );
- DALI_TEST_CHECK( rootActor == rootData.wheeledActor );
+ application.ProcessEvent(newEvent);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
+ DALI_TEST_EQUALS(true, rootData.functorCalled, TEST_LOCATION);
+ DALI_TEST_CHECK(rootActor == rootData.wheeledActor);
DALI_TEST_EQUALS(WheelEvent::MOUSE_WHEEL, rootData.receivedWheelEvent.GetType(), TEST_LOCATION); // check type
- DALI_TEST_EQUALS(0, rootData.receivedWheelEvent.GetDirection(), TEST_LOCATION); // check direction
- DALI_TEST_EQUALS(SHIFT_MODIFIER, rootData.receivedWheelEvent.GetModifiers(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(screenCoordinates, rootData.receivedWheelEvent.GetPoint(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(1, rootData.receivedWheelEvent.GetDelta(), TEST_LOCATION); // check modifier
- DALI_TEST_EQUALS(1000u, rootData.receivedWheelEvent.GetTime(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(0, rootData.receivedWheelEvent.GetDirection(), TEST_LOCATION); // check direction
+ DALI_TEST_EQUALS(SHIFT_MODIFIER, rootData.receivedWheelEvent.GetModifiers(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(screenCoordinates, rootData.receivedWheelEvent.GetPoint(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1, rootData.receivedWheelEvent.GetDelta(), TEST_LOCATION); // check modifier
+ DALI_TEST_EQUALS(1000u, rootData.receivedWheelEvent.GetTime(), TEST_LOCATION); // check modifier
// Remove actor from the scene
- application.GetScene().Remove( actor );
+ application.GetScene().Remove(actor);
// Render and notify
application.SendNotification();
application.Render();
// Emit a move at the same point, we should not be signalled.
- application.ProcessEvent( event );
- DALI_TEST_EQUALS( false, data.functorCalled, TEST_LOCATION );
+ application.ProcessEvent(event);
+ DALI_TEST_EQUALS(false, data.functorCalled, TEST_LOCATION);
data.Reset();
END_TEST;
}
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelActor
{
-
-Rect<> CalculateScreenExtents( Actor actor )
+Rect<> CalculateScreenExtents(Actor actor)
{
- return GetImplementation( actor ).CalculateScreenExtents();
+ return GetImplementation(actor).CalculateScreenExtents();
}
-VisibilityChangedSignalType& VisibilityChangedSignal( Actor actor )
+VisibilityChangedSignalType& VisibilityChangedSignal(Actor actor)
{
- return GetImplementation( actor ).VisibilityChangedSignal();
+ return GetImplementation(actor).VisibilityChangedSignal();
}
-ChildChangedSignalType& ChildAddedSignal( Actor actor )
+ChildChangedSignalType& ChildAddedSignal(Actor actor)
{
- return GetImplementation( actor ).ChildAddedSignal();
+ return GetImplementation(actor).ChildAddedSignal();
}
-ChildChangedSignalType& ChildRemovedSignal( Actor actor )
+ChildChangedSignalType& ChildRemovedSignal(Actor actor)
{
- return GetImplementation( actor ).ChildRemovedSignal();
+ return GetImplementation(actor).ChildRemovedSignal();
}
-ChildOrderChangedSignalType& ChildOrderChangedSignal( Actor actor )
+ChildOrderChangedSignalType& ChildOrderChangedSignal(Actor actor)
{
- return GetImplementation( actor ).ChildOrderChangedSignal();
+ return GetImplementation(actor).ChildOrderChangedSignal();
}
-
-
} // namespace DevelActor
} // namespace Dali
namespace Dali
{
-
namespace DevelActor
{
-
namespace Property
{
-
enum Type
{
- PARENT_ORIGIN = Dali::Actor::Property::PARENT_ORIGIN,
- PARENT_ORIGIN_X = Dali::Actor::Property::PARENT_ORIGIN_X,
- PARENT_ORIGIN_Y = Dali::Actor::Property::PARENT_ORIGIN_Y,
- PARENT_ORIGIN_Z = Dali::Actor::Property::PARENT_ORIGIN_Z,
- ANCHOR_POINT = Dali::Actor::Property::ANCHOR_POINT,
- ANCHOR_POINT_X = Dali::Actor::Property::ANCHOR_POINT_X,
- ANCHOR_POINT_Y = Dali::Actor::Property::ANCHOR_POINT_Y,
- ANCHOR_POINT_Z = Dali::Actor::Property::ANCHOR_POINT_Z,
- SIZE = Dali::Actor::Property::SIZE,
- SIZE_WIDTH = Dali::Actor::Property::SIZE_WIDTH,
- SIZE_HEIGHT = Dali::Actor::Property::SIZE_HEIGHT,
- SIZE_DEPTH = Dali::Actor::Property::SIZE_DEPTH,
- POSITION = Dali::Actor::Property::POSITION,
- POSITION_X = Dali::Actor::Property::POSITION_X,
- POSITION_Y = Dali::Actor::Property::POSITION_Y,
- POSITION_Z = Dali::Actor::Property::POSITION_Z,
- WORLD_POSITION = Dali::Actor::Property::WORLD_POSITION,
- WORLD_POSITION_X = Dali::Actor::Property::WORLD_POSITION_X,
- WORLD_POSITION_Y = Dali::Actor::Property::WORLD_POSITION_Y,
- WORLD_POSITION_Z = Dali::Actor::Property::WORLD_POSITION_Z,
- ORIENTATION = Dali::Actor::Property::ORIENTATION,
- WORLD_ORIENTATION = Dali::Actor::Property::WORLD_ORIENTATION,
- SCALE = Dali::Actor::Property::SCALE,
- SCALE_X = Dali::Actor::Property::SCALE_X,
- SCALE_Y = Dali::Actor::Property::SCALE_Y,
- SCALE_Z = Dali::Actor::Property::SCALE_Z,
- WORLD_SCALE = Dali::Actor::Property::WORLD_SCALE,
- VISIBLE = Dali::Actor::Property::VISIBLE,
- COLOR = Dali::Actor::Property::COLOR,
- COLOR_RED = Dali::Actor::Property::COLOR_RED,
- COLOR_GREEN = Dali::Actor::Property::COLOR_GREEN,
- COLOR_BLUE = Dali::Actor::Property::COLOR_BLUE,
- COLOR_ALPHA = Dali::Actor::Property::COLOR_ALPHA,
- WORLD_COLOR = Dali::Actor::Property::WORLD_COLOR,
- WORLD_MATRIX = Dali::Actor::Property::WORLD_MATRIX,
- NAME = Dali::Actor::Property::NAME,
- SENSITIVE = Dali::Actor::Property::SENSITIVE,
- LEAVE_REQUIRED = Dali::Actor::Property::LEAVE_REQUIRED,
- INHERIT_ORIENTATION = Dali::Actor::Property::INHERIT_ORIENTATION,
- INHERIT_SCALE = Dali::Actor::Property::INHERIT_SCALE,
- COLOR_MODE = Dali::Actor::Property::COLOR_MODE,
- DRAW_MODE = Dali::Actor::Property::DRAW_MODE,
- SIZE_MODE_FACTOR = Dali::Actor::Property::SIZE_MODE_FACTOR,
- WIDTH_RESIZE_POLICY = Dali::Actor::Property::WIDTH_RESIZE_POLICY,
- HEIGHT_RESIZE_POLICY = Dali::Actor::Property::HEIGHT_RESIZE_POLICY,
- SIZE_SCALE_POLICY = Dali::Actor::Property::SIZE_SCALE_POLICY,
- WIDTH_FOR_HEIGHT = Dali::Actor::Property::WIDTH_FOR_HEIGHT,
- HEIGHT_FOR_WIDTH = Dali::Actor::Property::HEIGHT_FOR_WIDTH,
- PADDING = Dali::Actor::Property::PADDING,
- MINIMUM_SIZE = Dali::Actor::Property::MINIMUM_SIZE,
- MAXIMUM_SIZE = Dali::Actor::Property::MAXIMUM_SIZE,
- INHERIT_POSITION = Dali::Actor::Property::INHERIT_POSITION,
- CLIPPING_MODE = Dali::Actor::Property::CLIPPING_MODE,
- LAYOUT_DIRECTION = Dali::Actor::Property::LAYOUT_DIRECTION,
- INHERIT_LAYOUT_DIRECTION = Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION,
- OPACITY = Dali::Actor::Property::OPACITY,
- SCREEN_POSITION = Dali::Actor::Property::SCREEN_POSITION,
- POSITION_USES_ANCHOR_POINT = Dali::Actor::Property::POSITION_USES_ANCHOR_POINT,
- CULLED = Dali::Actor::Property::CULLED,
- ID = Dali::Actor::Property::ID,
- HIERARCHY_DEPTH = Dali::Actor::Property::HIERARCHY_DEPTH,
- IS_ROOT = Dali::Actor::Property::IS_ROOT,
- IS_LAYER = Dali::Actor::Property::IS_LAYER,
- CONNECTED_TO_SCENE = Dali::Actor::Property::CONNECTED_TO_SCENE,
- KEYBOARD_FOCUSABLE = Dali::Actor::Property::KEYBOARD_FOCUSABLE,
+ PARENT_ORIGIN = Dali::Actor::Property::PARENT_ORIGIN,
+ PARENT_ORIGIN_X = Dali::Actor::Property::PARENT_ORIGIN_X,
+ PARENT_ORIGIN_Y = Dali::Actor::Property::PARENT_ORIGIN_Y,
+ PARENT_ORIGIN_Z = Dali::Actor::Property::PARENT_ORIGIN_Z,
+ ANCHOR_POINT = Dali::Actor::Property::ANCHOR_POINT,
+ ANCHOR_POINT_X = Dali::Actor::Property::ANCHOR_POINT_X,
+ ANCHOR_POINT_Y = Dali::Actor::Property::ANCHOR_POINT_Y,
+ ANCHOR_POINT_Z = Dali::Actor::Property::ANCHOR_POINT_Z,
+ SIZE = Dali::Actor::Property::SIZE,
+ SIZE_WIDTH = Dali::Actor::Property::SIZE_WIDTH,
+ SIZE_HEIGHT = Dali::Actor::Property::SIZE_HEIGHT,
+ SIZE_DEPTH = Dali::Actor::Property::SIZE_DEPTH,
+ POSITION = Dali::Actor::Property::POSITION,
+ POSITION_X = Dali::Actor::Property::POSITION_X,
+ POSITION_Y = Dali::Actor::Property::POSITION_Y,
+ POSITION_Z = Dali::Actor::Property::POSITION_Z,
+ WORLD_POSITION = Dali::Actor::Property::WORLD_POSITION,
+ WORLD_POSITION_X = Dali::Actor::Property::WORLD_POSITION_X,
+ WORLD_POSITION_Y = Dali::Actor::Property::WORLD_POSITION_Y,
+ WORLD_POSITION_Z = Dali::Actor::Property::WORLD_POSITION_Z,
+ ORIENTATION = Dali::Actor::Property::ORIENTATION,
+ WORLD_ORIENTATION = Dali::Actor::Property::WORLD_ORIENTATION,
+ SCALE = Dali::Actor::Property::SCALE,
+ SCALE_X = Dali::Actor::Property::SCALE_X,
+ SCALE_Y = Dali::Actor::Property::SCALE_Y,
+ SCALE_Z = Dali::Actor::Property::SCALE_Z,
+ WORLD_SCALE = Dali::Actor::Property::WORLD_SCALE,
+ VISIBLE = Dali::Actor::Property::VISIBLE,
+ COLOR = Dali::Actor::Property::COLOR,
+ COLOR_RED = Dali::Actor::Property::COLOR_RED,
+ COLOR_GREEN = Dali::Actor::Property::COLOR_GREEN,
+ COLOR_BLUE = Dali::Actor::Property::COLOR_BLUE,
+ COLOR_ALPHA = Dali::Actor::Property::COLOR_ALPHA,
+ WORLD_COLOR = Dali::Actor::Property::WORLD_COLOR,
+ WORLD_MATRIX = Dali::Actor::Property::WORLD_MATRIX,
+ NAME = Dali::Actor::Property::NAME,
+ SENSITIVE = Dali::Actor::Property::SENSITIVE,
+ LEAVE_REQUIRED = Dali::Actor::Property::LEAVE_REQUIRED,
+ INHERIT_ORIENTATION = Dali::Actor::Property::INHERIT_ORIENTATION,
+ INHERIT_SCALE = Dali::Actor::Property::INHERIT_SCALE,
+ COLOR_MODE = Dali::Actor::Property::COLOR_MODE,
+ DRAW_MODE = Dali::Actor::Property::DRAW_MODE,
+ SIZE_MODE_FACTOR = Dali::Actor::Property::SIZE_MODE_FACTOR,
+ WIDTH_RESIZE_POLICY = Dali::Actor::Property::WIDTH_RESIZE_POLICY,
+ HEIGHT_RESIZE_POLICY = Dali::Actor::Property::HEIGHT_RESIZE_POLICY,
+ SIZE_SCALE_POLICY = Dali::Actor::Property::SIZE_SCALE_POLICY,
+ WIDTH_FOR_HEIGHT = Dali::Actor::Property::WIDTH_FOR_HEIGHT,
+ HEIGHT_FOR_WIDTH = Dali::Actor::Property::HEIGHT_FOR_WIDTH,
+ PADDING = Dali::Actor::Property::PADDING,
+ MINIMUM_SIZE = Dali::Actor::Property::MINIMUM_SIZE,
+ MAXIMUM_SIZE = Dali::Actor::Property::MAXIMUM_SIZE,
+ INHERIT_POSITION = Dali::Actor::Property::INHERIT_POSITION,
+ CLIPPING_MODE = Dali::Actor::Property::CLIPPING_MODE,
+ LAYOUT_DIRECTION = Dali::Actor::Property::LAYOUT_DIRECTION,
+ INHERIT_LAYOUT_DIRECTION = Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION,
+ OPACITY = Dali::Actor::Property::OPACITY,
+ SCREEN_POSITION = Dali::Actor::Property::SCREEN_POSITION,
+ POSITION_USES_ANCHOR_POINT = Dali::Actor::Property::POSITION_USES_ANCHOR_POINT,
+ CULLED = Dali::Actor::Property::CULLED,
+ ID = Dali::Actor::Property::ID,
+ HIERARCHY_DEPTH = Dali::Actor::Property::HIERARCHY_DEPTH,
+ IS_ROOT = Dali::Actor::Property::IS_ROOT,
+ IS_LAYER = Dali::Actor::Property::IS_LAYER,
+ CONNECTED_TO_SCENE = Dali::Actor::Property::CONNECTED_TO_SCENE,
+ KEYBOARD_FOCUSABLE = Dali::Actor::Property::KEYBOARD_FOCUSABLE,
/**
* @brief Sets the sibling order of the actor so depth position can be defined within the same parent.
namespace VisibilityChange
{
-
enum Type
{
- SELF, ///< The visibility of the actor itself has changed.
- PARENT ///< The visibility of a parent has changed.
+ SELF, ///< The visibility of the actor itself has changed.
+ PARENT ///< The visibility of a parent has changed.
};
} // namespace VisibilityChange
-typedef Signal< void ( Actor, bool, VisibilityChange::Type ) > VisibilityChangedSignalType; ///< Signal type of VisibilityChangedSignalType
+using VisibilityChangedSignalType = Signal<void(Actor, bool, VisibilityChange::Type)>; ///< Signal type of VisibilityChangedSignalType
/**
* @brief This signal is emitted when the visible property of this or a parent actor is changed.
* @pre The Actor has been initialized.
* @note This signal is NOT emitted if the actor becomes transparent (or the reverse), it's only linked with Actor::Property::VISIBLE.
*/
-DALI_CORE_API VisibilityChangedSignalType& VisibilityChangedSignal( Actor actor );
+DALI_CORE_API VisibilityChangedSignalType& VisibilityChangedSignal(Actor actor);
/**
* Calculates screen position and size.
*
* @return pair of two values, position of top-left corner on screen and size respectively.
*/
-DALI_CORE_API Rect<> CalculateScreenExtents( Actor actor );
-
+DALI_CORE_API Rect<> CalculateScreenExtents(Actor actor);
-
-typedef Signal< void (Actor) > ChildChangedSignalType; ///< Called when the actor has a child added or removed
+using ChildChangedSignalType = Signal<void(Actor)>; ///< Called when the actor has a child added or removed
/**
* @brief This signal is emitted when a child is added to this actor.
* @return The signal to connect to
* @pre The Actor has been initialized
*/
-DALI_CORE_API ChildChangedSignalType& ChildAddedSignal( Actor actor );
+DALI_CORE_API ChildChangedSignalType& ChildAddedSignal(Actor actor);
/**
* @brief This signal is emitted when a child is removed from this actor.
* @return The signal to connect to
* @pre The Actor has been initialized
*/
-DALI_CORE_API ChildChangedSignalType& ChildRemovedSignal( Actor actor );
-
+DALI_CORE_API ChildChangedSignalType& ChildRemovedSignal(Actor actor);
-typedef Signal< void (Actor) > ChildOrderChangedSignalType; ///< Used when the actor's children have changed order
+using ChildOrderChangedSignalType = Signal<void(Actor)>; ///< Used when the actor's children have changed order
/**
* @brief This signal is emitted when an actor's children change their sibling order
* @return The signal to connect to
* @pre The Actor has been initialized
*/
-DALI_CORE_API ChildOrderChangedSignalType& ChildOrderChangedSignal( Actor actor );
-
-
+DALI_CORE_API ChildOrderChangedSignalType& ChildOrderChangedSignal(Actor actor);
} // namespace DevelActor
*
*/
-#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/actors/camera-actor.h>
namespace Dali
{
};
} // Namespace Property
-} // Namesapce DevelCameraActor
+} // namespace DevelCameraActor
} // Namespace Dali
#endif // DALI_CAMERA_ACTOR_DEVEL_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelCustomActor
{
-
-const Dali::TypeInfo GetTypeInfo( CustomActor actor )
+const Dali::TypeInfo GetTypeInfo(CustomActor actor)
{
return actor.GetImplementation().GetOwner()->GetTypeInfo();
}
#define DALI_CUSTOM_ACTOR_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelCustomActor
{
-
/**
* Get the type info for the CustomActor.
* This is useful when the type information has been set via
* @param[in] actor The custom actor of which to get the type information
* @return the TypeInfo of this actor
*/
-DALI_CORE_API const Dali::TypeInfo GetTypeInfo( CustomActor actor );
+DALI_CORE_API const Dali::TypeInfo GetTypeInfo(CustomActor actor);
} // namespace DevelCustomActor
#define DALI_LAYER_DEVEL_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelLayer
{
-
- /**
+/**
* @brief ACTOR_DEPTH_MULTIPLIER is used by the rendering sorting algorithm to decide which actors to render first.
* @SINCE_1_0.0
*/
- enum ActorDepthMultiplier
- {
- ACTOR_DEPTH_MULTIPLIER = 1000000,
- };
+enum ActorDepthMultiplier
+{
+ ACTOR_DEPTH_MULTIPLIER = 1000000,
+};
- /**
+/**
* @brief SIBLING_ORDER_MULTIPLIER is used by the rendering sorting algorithm to decide which actors to render first.
* @SINCE_1_2.16
*/
- enum SiblingOrderMultiplier
- {
- SIBLING_ORDER_MULTIPLIER = 1000,
- };
+enum SiblingOrderMultiplier
+{
+ SIBLING_ORDER_MULTIPLIER = 1000,
+};
-}
+} // namespace DevelLayer
-}
+} // namespace Dali
-#endif //DALI_LAYER_DEVEL_H
+#endif //DALI_LAYER_DEVEL_H
*
*/
-#include <dali/integration-api/addon-manager.h>
#include <dali/devel-api/addons/addon-dispatch-table.h>
+#include <dali/integration-api/addon-manager.h>
#include <vector>
namespace Dali
{
namespace AddOns
{
-
/**
* @class AddOnBase
*
class AddOnBase
{
protected:
-
/**
* @brief Constructor
*/
}
public:
-
/**
* @brief Destructor
*/
* @brief Retrieves AddOn info
* @param[out] addonInfo AddOnInfo structure to fill by the function
*/
- virtual void GetAddOnInfo( Dali::AddOnInfo& addonInfo ) = 0;
+ virtual void GetAddOnInfo(Dali::AddOnInfo& addonInfo) = 0;
/**
* @brief Returns a dispatch table for global functions.
* @brief OnStart event.
* It's optional and should be implemented by the AddOn when it's required to handle the event.
*/
- virtual void OnStart() {}
+ virtual void OnStart()
+ {
+ }
/**
* @brief OnResume event.
* It's optional and should be implemented by the AddOn when it's required to handle the event.
*/
- virtual void OnResume() {}
+ virtual void OnResume()
+ {
+ }
/**
* @brief OnPause event.
* It's optional and should be implemented by the AddOn when it's required to handle the event.
*/
- virtual void OnPause() {}
+ virtual void OnPause()
+ {
+ }
/**
* @brief OnStop event.
* It's optional and should be implemented by the AddOn when it's required to handle the event.
*/
- virtual void OnStop() {}
+ virtual void OnStop()
+ {
+ }
/**
* @brief Getter of static singleton
}
private:
-
static AddOnBase* mSingleton;
};
* @param[out] info Reference to AddOnInfo structure
*/
template<class T>
-void GetAddOnInfo( Dali::AddOnInfo& info )
+void GetAddOnInfo(Dali::AddOnInfo& info)
{
auto* addon = Dali::AddOns::AddOnBase::Get();
- addon->GetAddOnInfo( info );
+ addon->GetAddOnInfo(info);
}
/**
* @return Valid pointer or nullptr if function not found.
*/
template<class T>
-void* GetGlobalProc( const char* funcname )
+void* GetGlobalProc(const char* funcname)
{
- if( !funcname )
+ if(!funcname)
{
return nullptr;
}
auto* addon = Dali::AddOns::AddOnBase::Get();
// AddOn must be initialised up to this point!
- if( !addon )
+ if(!addon)
{
return nullptr;
}
static Dali::AddOns::DispatchTable* globalDispatchTable = addon->GetGlobalDispatchTable();
- if( globalDispatchTable )
+ if(globalDispatchTable)
{
- return globalDispatchTable->Find( funcname );
+ return globalDispatchTable->Find(funcname);
}
return nullptr;
}
* @return Valid pointer or nullptr if function not found.
*/
template<class T>
-void* GetInstanceProc( const char* funcname )
+void* GetInstanceProc(const char* funcname)
{
- if( !funcname )
+ if(!funcname)
{
return nullptr;
}
auto* addon = Dali::AddOns::AddOnBase::Get();
// AddOn must be initialised up to this point!
- if( !addon )
+ if(!addon)
{
return nullptr;
}
static Dali::AddOns::DispatchTable* instanceDispatchTable = addon->GetInstanceDispatchTable();
- if( instanceDispatchTable )
+ if(instanceDispatchTable)
{
- return instanceDispatchTable->Find( funcname );
+ return instanceDispatchTable->Find(funcname);
}
return nullptr;
}
auto* addon = Dali::AddOns::CreateAddOn();
Dali::AddOnInfo info{};
- addon->GetAddOnInfo( info );
+ addon->GetAddOnInfo(info);
// Generate dispatch tables
addon->GetGlobalDispatchTable();
// Bind basic functions
Dali::AddOnDispatchTable table;
- table.name = info.name;
- table.GetAddOnInfo = GetAddOnInfo<void>;
- table.GetGlobalProc = GetGlobalProc<void>;
+ table.name = info.name;
+ table.GetAddOnInfo = GetAddOnInfo<void>;
+ table.GetGlobalProc = GetGlobalProc<void>;
table.GetInstanceProc = GetInstanceProc<void>;
- table.OnStart = OnStart<void>;
- table.OnStop = OnStop<void>;
- table.OnResume = OnResume<void>;
- table.OnPause = OnPause<void>;
+ table.OnStart = OnStart<void>;
+ table.OnStop = OnStop<void>;
+ table.OnResume = OnResume<void>;
+ table.OnPause = OnPause<void>;
// Register dispatch table
- Dali::Integration::AddOnManager::Get()->RegisterAddOnDispatchTable( &table );
+ Dali::Integration::AddOnManager::Get()->RegisterAddOnDispatchTable(&table);
}
} // namespace AddOns
* Note: The macro requires GCC/Clang compiler and currently only Linux-based environment
* is supported.
*/
-#define REGISTER_ADDON_CLASS( ADDON_CLASS_WITH_FULL_NAMESPACE ) \
-namespace Dali { namespace AddOns { \
-__attribute__((constructor)) void AddOnConstructor() { \
- AddOnConstructorInternal();\
-}\
-AddOnBase* AddOnBase::mSingleton = nullptr; \
-AddOnBase* CreateAddOn() \
-{\
- return new ADDON_CLASS_WITH_FULL_NAMESPACE();\
-}\
-}}
+#define REGISTER_ADDON_CLASS(ADDON_CLASS_WITH_FULL_NAMESPACE) \
+ namespace Dali \
+ { \
+ namespace AddOns \
+ { \
+ __attribute__((constructor)) void AddOnConstructor() \
+ { \
+ AddOnConstructorInternal(); \
+ } \
+ AddOnBase* AddOnBase::mSingleton = nullptr; \
+ AddOnBase* CreateAddOn() \
+ { \
+ return new ADDON_CLASS_WITH_FULL_NAMESPACE(); \
+ } \
+ } \
+ }
#endif // DALI_ADDON_BASE_H
*
*/
+#include <string>
+#include <algorithm>
+#include <dali/public-api/common/vector-wrapper.h>
+
namespace Dali
{
namespace AddOns
{
-
/**
* DispatchTable contains essential function pointers
* needed to register the AddOn with AddOnManager.
* @return Reference to self
*/
template<class T>
- Entry &operator=(T funcPtr)
+ Entry& operator=(T funcPtr)
{
- functionPtr = reinterpret_cast<void *>( funcPtr );
- if (index < 0)
+ functionPtr = reinterpret_cast<void*>(funcPtr);
+ if(index < 0)
{
index = int32_t(table->entries.size());
table->entries.emplace_back(*this);
}
else
{
- table->entries[index].functionPtr = reinterpret_cast<void *>( funcPtr );
+ table->entries[index].functionPtr = reinterpret_cast<void*>(funcPtr);
}
return *this;
}
- std::string functionName{}; ///< Name of function
- void* functionPtr{nullptr}; ///< Function pointer
- DispatchTable* table{nullptr}; ///< DispatchTable associated with entry
- int32_t index = -1; ///< Index within the dispatch table
+ std::string functionName{}; ///< Name of function
+ void* functionPtr{nullptr}; ///< Function pointer
+ DispatchTable* table{nullptr}; ///< DispatchTable associated with entry
+ int32_t index = -1; ///< Index within the dispatch table
};
/**
* @param[in] functionName name of function
* @return Returns Entry object
*/
- Entry operator[](const char *functionName)
+ Entry operator[](const char* functionName)
{
- auto iter = std::find_if(entries.begin(), entries.end(), [functionName](Entry &entry)
- {
- if (entry.functionName == functionName)
+ auto iter = std::find_if(entries.begin(), entries.end(), [functionName](Entry& entry) {
+ if(entry.functionName == functionName)
{
return true;
}
return false;
});
- if (iter == entries.end())
+
+ if(iter == entries.end())
{
Entry retval;
retval.table = this;
* @param[in] funcName Name of function
* @return valid pointer or nullptr if function not found
*/
- FunctionPointer Find(const char *funcName)
+ FunctionPointer Find(const char* funcName)
{
- if (entries.empty())
+ if(entries.empty())
{
return nullptr;
}
- auto iter = std::find_if(entries.begin(), entries.end(), [funcName, entries = &this->entries](Entry &entry)
- {
+ auto iter = std::find_if(entries.begin(), entries.end(), [funcName, entries = &this->entries](Entry& entry) {
return (entry.functionName == funcName);
});
- if (iter != entries.end())
+ if(iter != entries.end())
{
return iter->functionPtr;
}
return nullptr;
}
- std::vector <Entry> entries;
+ std::vector<Entry> entries;
};
} // namespace AddOns
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-
AnimationData::AnimationData()
{
}
Clear();
}
-
-void AnimationData::Add( AnimationDataElement* animationDataElement )
+void AnimationData::Add(AnimationDataElement* animationDataElement)
{
- mAnimationDataList.PushBack( animationDataElement );
+ mAnimationDataList.PushBack(animationDataElement);
}
-
-Dali::Animation AnimationData::CreateAnimation( Dali::Actor targetActor, float duration )
+Dali::Animation AnimationData::CreateAnimation(Dali::Actor targetActor, float duration)
{
Dali::Animation animation;
- if( mAnimationDataList.Size() > 0 )
+ if(mAnimationDataList.Size() > 0)
{
- animation = Dali::Animation::New( duration );
+ animation = Dali::Animation::New(duration);
// Setup an Animation from AnimationData.
AnimationData::AnimationDataList::Iterator end = mAnimationDataList.End();
- for( AnimationData::AnimationDataList::Iterator iter = mAnimationDataList.Begin(); iter != end; ++iter )
+ for(AnimationData::AnimationDataList::Iterator iter = mAnimationDataList.Begin(); iter != end; ++iter)
{
// Override the actor in the animation.
- animation.AnimateTo( Property( targetActor, ( *iter )->property ), ( *iter )->value,
- ( *iter )->alphaFunction, TimePeriod( ( *iter )->timePeriodDelay, ( *iter )->timePeriodDuration ) );
+ animation.AnimateTo(Property(targetActor, (*iter)->property),
+ (*iter)->value,
+ (*iter)->alphaFunction,
+ TimePeriod((*iter)->timePeriodDelay, (*iter)->timePeriodDuration));
}
}
return animation;
}
-
void AnimationData::Clear()
{
AnimationData::AnimationDataList::Iterator end = mAnimationDataList.End();
- for( AnimationData::AnimationDataList::Iterator iter = mAnimationDataList.Begin(); iter != end; ++iter )
+ for(AnimationData::AnimationDataList::Iterator iter = mAnimationDataList.Begin(); iter != end; ++iter)
{
- delete ( *iter );
+ delete(*iter);
}
mAnimationDataList.Clear();
}
-
} // namespace Dali
#define DALI_ANIMATION_DATA_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @brief This object stores description data that can be used to generate an Animation.
* This data can be produced from passing JSON.
class DALI_CORE_API AnimationData
{
public:
-
AnimationData();
~AnimationData();
*/
struct AnimationDataElement
{
- std::string actor;
- std::string property;
- Property::Value value;
+ std::string actor;
+ std::string property;
+ Property::Value value;
AlphaFunction::BuiltinFunction alphaFunction;
- float timePeriodDelay;
- float timePeriodDuration;
+ float timePeriodDelay;
+ float timePeriodDuration;
AnimationDataElement()
- : alphaFunction( AlphaFunction::DEFAULT ),
- timePeriodDelay( 0.0f ),
- timePeriodDuration( 1.0f )
+ : alphaFunction(AlphaFunction::DEFAULT),
+ timePeriodDelay(0.0f),
+ timePeriodDuration(1.0f)
{
}
};
-
/**
* @brief AnimationData holds the required data required to define an
* animation to be performed on an actor or actors.
*/
- typedef Dali::Vector< AnimationDataElement* > AnimationDataList;
-
+ using AnimationDataList = Dali::Vector<AnimationDataElement*>;
/**
* @brief Adds one AnimationDataElement to the list to describe one animation.
* @param[in] animationDataElement A pre-populated struct to add
* @note This class takes ownership of animationDataElement
*/
- void Add( AnimationDataElement* animationDataElement );
-
+ void Add(AnimationDataElement* animationDataElement);
/**
* @brief Creates a Dali::Animation from this AnimationData object.
* @param[in] duration The duration of the animation to create.
* @return A ready-to-go Dali::Animation, or an invalid handle if there was no data.
*/
- Dali::Animation CreateAnimation( Dali::Actor targetActor, float duration );
-
+ Dali::Animation CreateAnimation(Dali::Actor targetActor, float duration);
/**
* @brief Empties this AnimationData object (and frees all memory).
void Clear();
private:
-
AnimationDataList mAnimationDataList; ///< A vector of individual property animations from which to generate a Dali::Animation.
-
};
-
} // namespace Dali
#endif // DALI_ANIMATION_DATA_H
-
// INTERNAL INCLUDES
#include <dali/devel-api/animation/animation-devel.h>
#include <dali/internal/event/animation/animation-impl.h>
-#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/internal/event/animation/animation-playlist.h>
+#include <dali/internal/event/common/thread-local-storage.h>
namespace Dali
{
-
namespace DevelAnimation
{
-
-void SetProgressNotification( Animation animation, float progress )
+void SetProgressNotification(Animation animation, float progress)
{
- GetImplementation(animation).SetProgressNotification( progress );
+ GetImplementation(animation).SetProgressNotification(progress);
}
-float GetProgressNotification( Animation animation )
+float GetProgressNotification(Animation animation)
{
return GetImplementation(animation).GetProgressNotification();
}
-Animation::AnimationSignalType& ProgressReachedSignal( Animation animation )
+Animation::AnimationSignalType& ProgressReachedSignal(Animation animation)
{
- return GetImplementation( animation ).ProgressReachedSignal();
+ return GetImplementation(animation).ProgressReachedSignal();
}
uint32_t GetAnimationCount()
return tls.GetAnimationPlaylist().GetAnimationCount();
}
-Animation GetAnimationAt( uint32_t index )
+Animation GetAnimationAt(uint32_t index)
{
Dali::Internal::ThreadLocalStorage& tls = Dali::Internal::ThreadLocalStorage::Get();
- return tls.GetAnimationPlaylist().GetAnimationAt( index );
+ return tls.GetAnimationPlaylist().GetAnimationAt(index);
}
} // namespace DevelAnimation
namespace Dali
{
-
namespace DevelAnimation
{
-
/**
* @brief Set progress percentage marker to trigger ProgressHasBeenReachedSignal
*
* @param[in] animation the animation object to perform this operation on
* @param[in] progress the progress percentage to trigger the signal at, e.g .3 for 30%.
*/
-DALI_CORE_API void SetProgressNotification( Animation animation, float progress );
+DALI_CORE_API void SetProgressNotification(Animation animation, float progress);
/**
* @brief Get progress percentage marker that has been set to trigger ProgressHasBeenReachedSignal
* @param[in] animation the animation object to perform this operation on
* @return the percentage to trigger at eg 0.3 for 30%
*/
-DALI_CORE_API float GetProgressNotification( Animation animation );
+DALI_CORE_API float GetProgressNotification(Animation animation);
/**
* @brief Connects to this signal to be notified when an Animation's animations have reached set progress.
*
* @return A signal object to connect with
*/
-DALI_CORE_API Animation::AnimationSignalType& ProgressReachedSignal( Animation animation );
+DALI_CORE_API Animation::AnimationSignalType& ProgressReachedSignal(Animation animation);
/**
* @brief Retrive the number of Animations.
* @param[in] index The index of the Animation to retrieve
* @return The animation for the given index or empty handle
*/
-DALI_CORE_API Animation GetAnimationAt( uint32_t index );
+DALI_CORE_API Animation GetAnimationAt(uint32_t index);
} // namespace DevelAnimation
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
PathConstrainer PathConstrainer::New()
{
Internal::PathConstrainer* internal = Internal::PathConstrainer::New();
return PathConstrainer(internal);
}
-PathConstrainer PathConstrainer::DownCast( BaseHandle handle )
+PathConstrainer PathConstrainer::DownCast(BaseHandle handle)
{
- return PathConstrainer( dynamic_cast<Dali::Internal::PathConstrainer*>(handle.GetObjectPtr()) );
+ return PathConstrainer(dynamic_cast<Dali::Internal::PathConstrainer*>(handle.GetObjectPtr()));
}
PathConstrainer::PathConstrainer()
}
PathConstrainer::PathConstrainer(const PathConstrainer& handle)
-:Handle(handle)
+: Handle(handle)
{
}
return *this;
}
-void PathConstrainer::Apply( Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap )
+void PathConstrainer::Apply(Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap)
{
- GetImplementation(*this).Apply( target, source, range, wrap );
+ GetImplementation(*this).Apply(target, source, range, wrap);
}
-void PathConstrainer::Remove( Dali::Handle& target )
+void PathConstrainer::Remove(Dali::Handle& target)
{
- GetImplementation(*this).Remove( target );
+ GetImplementation(*this).Remove(target);
}
-
-} // Dali
+} // namespace Dali
#define DALI_PATH_CONSTRAINER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
- class PathConstrainer;
+class PathConstrainer;
}
/**
* @brief
class DALI_CORE_API PathConstrainer : public Handle
{
public:
-
/**
* @brief An enumeration of properties belonging to the PathConstrainer class.
*/
{
enum
{
- FORWARD = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "forward" type Vector3
- POINTS, ///< name "points" type Array of Vector3
- CONTROL_POINTS ///< name "controlPoints" type Array of Vector3
+ FORWARD = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "forward" type Vector3
+ POINTS, ///< name "points" type Array of Vector3
+ CONTROL_POINTS ///< name "controlPoints" type Array of Vector3
};
};
* @param[in] handle to An object
* @return handle to a PathConstrainer object or an uninitialized handle
*/
- static PathConstrainer DownCast( BaseHandle handle );
+ static PathConstrainer DownCast(BaseHandle handle);
/**
* @brief Create an uninitialized PathConstrainer handle.
* @param[in] range The range of values in the source property which will be mapped to [0,1]
* @param[in] wrap Wrapping domain. Source property will be wrapped in the domain [wrap.x,wrap.y] before mapping to [0,1]
*/
- void Apply( Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap = Vector2(-FLT_MAX, FLT_MAX) );
+ void Apply(Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap = Vector2(-FLT_MAX, FLT_MAX));
/**
* @brief Removes the path constraint in the target object
*
* @param[in] target A handle to an object constrained by the PathConstrainer
*/
- void Remove( Dali::Handle& target );
+ void Remove(Dali::Handle& target);
public: // Not intended for application developers
/**
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace AddOn
{
-
Dali::Integration::AddOnManager* AddOnBinder::mAddOnManager = nullptr;
} // namespace AddOn
{
namespace AddOn
{
-
/**
* Class automates binding an AddOn interface.
*
class AddOnBinder
{
public:
-
/**
* @brief Constructor. Opens an AddOn and creates interface
* @param[in] addonName Name of AddOn
* @param[in] version Version of AddOn
*/
- explicit AddOnBinder( const char* addonName, uint32_t version = 0u )
+ explicit AddOnBinder(const char* addonName, uint32_t version = 0u)
{
mAddOnManager = Dali::Integration::AddOnManager::Get();
- if (mAddOnManager)
+ if(mAddOnManager)
{
mAddOnHandle = mAddOnManager->GetAddOn(addonName);
- if (mAddOnHandle)
+ if(mAddOnHandle)
{
mAddOnManager->GetAddOnInfo(addonName, mAddOnInfo);
}
* @return Returns a new pointer
*/
template<class T>
- T* ConvertFunction( const std::string& funcName )
+ T* ConvertFunction(const std::string& funcName)
{
if(mAddOnHandle)
{
* @param[in] name Name of the function
* @return Valid pointer or nullptr
*/
- void* GetGlobalProc( const char* name )
+ void* GetGlobalProc(const char* name)
{
- return mAddOnManager ? mAddOnManager->GetGlobalProc( mAddOnHandle, name ) : nullptr;
+ return mAddOnManager ? mAddOnManager->GetGlobalProc(mAddOnHandle, name) : nullptr;
}
/**
* @param[in] name Name of the function
* @return Valid pointer or nullptr
*/
- void* GetInstanceProc( const char* name )
+ void* GetInstanceProc(const char* name)
{
- return mAddOnManager ? mAddOnManager->GetInstanceProc( mAddOnHandle, name ) : nullptr;
+ return mAddOnManager ? mAddOnManager->GetInstanceProc(mAddOnHandle, name) : nullptr;
}
/**
}
protected:
-
static DALI_CORE_API Dali::Integration::AddOnManager* mAddOnManager; ///< Pointer to the AddOn manager
- Dali::AddOnLibrary mAddOnHandle { nullptr }; ///< Handle to the AddOn library
- Dali::AddOnInfo mAddOnInfo {}; ///< Stored AddOnInfo structure
+ Dali::AddOnLibrary mAddOnHandle{nullptr}; ///< Handle to the AddOn library
+ Dali::AddOnInfo mAddOnInfo{}; ///< Stored AddOnInfo structure
};
-
/**
* Macro binds function as a member function of the class, for example, the call:
*
*
* will create a std::function object named SomeAddOnFunction and bound to the AddOn library.
*/
-#define ADDON_BIND_FUNCTION( FUNCNAME, FUNCTYPE ) \
-std::function<FUNCTYPE> FUNCNAME{ConvertFunction<FUNCTYPE>( std::string(#FUNCNAME) )};
+#define ADDON_BIND_FUNCTION(FUNCNAME, FUNCTYPE) \
+ std::function<FUNCTYPE> FUNCNAME{ConvertFunction<FUNCTYPE>(std::string(#FUNCNAME))};
} // namespace AddOn
} // namespace Dali
#define DALI_BITWISE_ENUM_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* Type traits and methods to enable type safe bit field operators for an enum.
* usage:
* if( myFlag & FLAG2 )
* // do something
*/
-template< typename Enum >
+template<typename Enum>
struct EnableBitMaskOperators
{
static const bool ENABLE = false; // can't be constexpr as it's a data member
* @param rhs bitfield to or
* @return EnumType with both flags set
*/
-template < typename EnumType >
-inline typename std::enable_if< EnableBitMaskOperators< EnumType >::ENABLE, EnumType >::type operator|( EnumType lhs, EnumType rhs )
+template<typename EnumType>
+inline typename std::enable_if<EnableBitMaskOperators<EnumType>::ENABLE, EnumType>::type operator|(EnumType lhs, EnumType rhs)
{
using UnderlyingType = typename std::underlying_type<EnumType>::type;
- return static_cast<EnumType>( static_cast<UnderlyingType>( lhs ) | static_cast<UnderlyingType>(rhs ) );
+ return static_cast<EnumType>(static_cast<UnderlyingType>(lhs) | static_cast<UnderlyingType>(rhs));
}
/**
* @param rhs bitfield to or
* @return reference to lhs with both flags set
*/
-template < typename EnumType >
-inline typename std::enable_if< EnableBitMaskOperators< EnumType >::ENABLE, EnumType& >::type operator|=( EnumType& lhs, EnumType rhs )
+template<typename EnumType>
+inline typename std::enable_if<EnableBitMaskOperators<EnumType>::ENABLE, EnumType&>::type operator|=(EnumType& lhs, EnumType rhs)
{
using UnderlyingType = typename std::underlying_type<EnumType>::type;
- lhs = static_cast<EnumType>(static_cast<UnderlyingType>( lhs ) | static_cast<UnderlyingType>( rhs ) );
+ lhs = static_cast<EnumType>(static_cast<UnderlyingType>(lhs) | static_cast<UnderlyingType>(rhs));
return lhs;
}
* @param rhs bitfield to AND
* @return true if at least one flag is same in both
*/
-template < typename EnumType >
-inline typename std::enable_if< EnableBitMaskOperators< EnumType >::ENABLE, bool >::type operator&( EnumType lhs, EnumType rhs )
+template<typename EnumType>
+inline typename std::enable_if<EnableBitMaskOperators<EnumType>::ENABLE, bool>::type operator&(EnumType lhs, EnumType rhs)
{
using UnderlyingType = typename std::underlying_type<EnumType>::type;
- return static_cast<bool>( static_cast<UnderlyingType>( lhs ) & static_cast<UnderlyingType>(rhs ) );
+ return static_cast<bool>(static_cast<UnderlyingType>(lhs) & static_cast<UnderlyingType>(rhs));
}
} // namespace Dali
#define DALI_CIRCULAR_QUEUE_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* Class to provide a circular growable queue on top of Dali::Vector
* It is designed to occupy a fixed block of memory. It does not allow
* addition of elements past the start; i.e. it doesn't overwrite.
*/
-template <typename ElementType>
+template<typename ElementType>
class CircularQueue
{
public:
* Constructor
* @param[in] maximumSize The maximum number of elements that the queue can contain
*/
- CircularQueue( int maximumSize )
+ CircularQueue(int maximumSize)
: mMaximumSize(maximumSize),
mStartMarker(0),
mEndMarker(0),
ElementType& operator[](unsigned int index)
{
unsigned int actualIndex = (mStartMarker + index) % mMaximumSize;
- DALI_ASSERT_ALWAYS( actualIndex<mQueue.Count() && "Reading outside queue boundary");
+ DALI_ASSERT_ALWAYS(actualIndex < mQueue.Count() && "Reading outside queue boundary");
return mQueue[actualIndex];
}
const ElementType& operator[](unsigned int index) const
{
unsigned int actualIndex = (mStartMarker + index) % mMaximumSize;
- DALI_ASSERT_ALWAYS( actualIndex<mQueue.Count() && "Reading outside queue boundary");
+ DALI_ASSERT_ALWAYS(actualIndex < mQueue.Count() && "Reading outside queue boundary");
return mQueue[actualIndex];
}
* @warning This method asserts if the user attempts to push more elements
* than the maximum size specified in the constructor
*/
- void PushBack( const ElementType& element )
+ void PushBack(const ElementType& element)
{
- DALI_ASSERT_ALWAYS( !IsFull() && "Adding to full queue");
+ DALI_ASSERT_ALWAYS(!IsFull() && "Adding to full queue");
// Push back if we need to increase the vector count
- if( mQueue.Count() == 0 || ( mQueue.Count() < mMaximumSize && ! IsEmpty() ) )
+ if(mQueue.Count() == 0 || (mQueue.Count() < mMaximumSize && !IsEmpty()))
{
mQueue.PushBack(element);
- if( !IsEmpty() )
+ if(!IsEmpty())
{
++mEndMarker;
}
++mNumberOfElements;
}
- else if( IsEmpty() )
+ else if(IsEmpty())
{
// Don't advance the end marker or increase the vector count
mQueue[mEndMarker] = element;
++mNumberOfElements;
}
- else if( !IsFull() )
+ else if(!IsFull())
{
// vector is at max and there is space: advance end marker
++mEndMarker;
mEndMarker %= mMaximumSize;
- mQueue[ mEndMarker ] = element;
+ mQueue[mEndMarker] = element;
++mNumberOfElements;
}
}
*/
ElementType PopFront()
{
- DALI_ASSERT_ALWAYS( !IsEmpty() && "Reading from empty queue" );
+ DALI_ASSERT_ALWAYS(!IsEmpty() && "Reading from empty queue");
ElementType element;
- if( mNumberOfElements == 1 )
+ if(mNumberOfElements == 1)
{
- element = mQueue[mStartMarker];
+ element = mQueue[mStartMarker];
mNumberOfElements = 0;
}
- else if( mNumberOfElements > 1 )
+ else if(mNumberOfElements > 1)
{
element = mQueue[mStartMarker];
++mStartMarker;
ElementType& Front()
{
- DALI_ASSERT_ALWAYS( !IsEmpty() && "Reading from empty queue" );
+ DALI_ASSERT_ALWAYS(!IsEmpty() && "Reading from empty queue");
return mQueue[mStartMarker];
}
const ElementType& Front() const
{
- DALI_ASSERT_ALWAYS( !IsEmpty() && "Reading from empty queue" );
+ DALI_ASSERT_ALWAYS(!IsEmpty() && "Reading from empty queue");
return mQueue[mStartMarker];
}
ElementType& Back()
{
- DALI_ASSERT_ALWAYS( !IsEmpty() && "Reading from empty queue" );
+ DALI_ASSERT_ALWAYS(!IsEmpty() && "Reading from empty queue");
return mQueue[mEndMarker];
}
const ElementType& Back() const
{
- DALI_ASSERT_ALWAYS( !IsEmpty() && "Reading from empty queue" );
+ DALI_ASSERT_ALWAYS(!IsEmpty() && "Reading from empty queue");
return mQueue[mEndMarker];
}
*/
bool IsFull() const
{
- return ( mQueue.Count() == mMaximumSize &&
- mNumberOfElements > 0 &&
- (mEndMarker + 1) % mMaximumSize == mStartMarker );
+ return (mQueue.Count() == mMaximumSize &&
+ mNumberOfElements > 0 &&
+ (mEndMarker + 1) % mMaximumSize == mStartMarker);
}
/**
int mNumberOfElements; ///< Number of valid elements in the queue
};
-} // Dali
+} // namespace Dali
#endif // DALI_CIRCULAR_QUEUE_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace //unnamed namespace
{
-
/*
* djb2 (http://www.cse.yorku.ca/~oz/hash.html)
*/
-inline void HashString( const char* string, std::size_t& hash )
+inline void HashString(const char* string, std::size_t& hash)
{
- while( int c = *string++ )
+ while(int c = *string++)
{
hash = hash * 33 + c;
}
} // unnamed namespace
-std::size_t CalculateHash( const std::string& toHash)
+std::size_t CalculateHash(const std::string& toHash)
{
- std::size_t hash( INITIAL_HASH_VALUE );
+ std::size_t hash(INITIAL_HASH_VALUE);
- HashString( toHash.c_str(), hash );
+ HashString(toHash.c_str(), hash);
return hash;
}
-std::size_t CalculateHash( const std::string& string1, const std::string& string2 )
+std::size_t CalculateHash(const std::string& string1, const std::string& string2)
{
- std::size_t hash( INITIAL_HASH_VALUE );
+ std::size_t hash(INITIAL_HASH_VALUE);
- HashString( string1.c_str(), hash);
- HashString( string2.c_str(), hash );
+ HashString(string1.c_str(), hash);
+ HashString(string2.c_str(), hash);
return hash;
}
#define DALI_HASH
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
enum
{
INITIAL_HASH_VALUE = 5381
* @param toHash string to hash
* @return hash code
*/
-DALI_CORE_API std::size_t CalculateHash( const std::string& toHash );
+DALI_CORE_API std::size_t CalculateHash(const std::string& toHash);
/**
* @brief Create a hash code for 2 strings combined.
* @param string2 second string
* @return hash code
*/
-DALI_CORE_API std::size_t CalculateHash( const std::string& string1, const std::string& string2 );
+DALI_CORE_API std::size_t CalculateHash(const std::string& string1, const std::string& string2);
} // namespace Dali
#define DALI_MAP_WRAPPER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <map>
#undef _LIBCPP_INLINE_VISIBILITY
-#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
+#define _LIBCPP_INLINE_VISIBILITY __attribute__((__visibility__("hidden"), __always_inline__))
#undef _LIBCPP_EXTERN_TEMPLATE
#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
#include <bits/stl_tree.h>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ ("hidden")))
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ ("hidden")))
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__("hidden")))
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__("hidden")))
#include <map>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY`
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY`
#endif // #ifdef __clang__
namespace Dali
{
-
/**
* OwnerContainer is a vector which own heap-allocated objects.
* Unlike vector this will call delete on the stored pointers during destruction.
*
* @endcode
*/
-template< class T >
-class OwnerContainer : public Dali::Vector< T >
+template<class T>
+class OwnerContainer : public Dali::Vector<T>
{
public:
-
- typedef typename Dali::Vector< T >::SizeType SizeType;
- typedef typename Vector< T >::Iterator Iterator;
- typedef typename Vector< T >::ConstIterator ConstIterator;
+ using SizeType = typename Dali::Vector<T>::SizeType;
+ using Iterator = typename Vector<T>::Iterator;
+ using ConstIterator = typename Vector<T>::ConstIterator;
/**
* Create a pointer-container.
*/
OwnerContainer()
- { }
+ {
+ }
/**
* Non-virtual destructor; OwnerContainer<T> is not suitable as base class.
}
// Not copyable or movable
- OwnerContainer( const OwnerContainer& ) = delete; ///< Deleted copy constructor
- OwnerContainer( OwnerContainer&& ) = delete; ///< Deleted move constructor
- OwnerContainer& operator=( const OwnerContainer& ) = delete; ///< Deleted copy assignment operator
- OwnerContainer& operator=( OwnerContainer&& ) = delete; ///< Deleted move assignment operator
+ OwnerContainer(const OwnerContainer&) = delete; ///< Deleted copy constructor
+ OwnerContainer(OwnerContainer&&) = delete; ///< Deleted move constructor
+ OwnerContainer& operator=(const OwnerContainer&) = delete; ///< Deleted copy assignment operator
+ OwnerContainer& operator=(OwnerContainer&&) = delete; ///< Deleted move assignment operator
/**
* Test whether the container is empty.
* @param[in] position A dereferencable iterator to an element in mContainer.
* @return iterator pointing to next element
*/
- Iterator Erase( Iterator position )
+ Iterator Erase(Iterator position)
{
- Delete (*position);
- return Vector< T >::Erase( position );
+ Delete(*position);
+ return Vector<T>::Erase(position);
}
/**
* Erase an object from OwnerContainer
* @param object to remove
*/
- inline void EraseObject( T object )
+ inline void EraseObject(T object)
{
- DALI_ASSERT_DEBUG( object && "NULL object not allowed" );
+ DALI_ASSERT_DEBUG(object && "NULL object not allowed");
- Iterator iter = Vector< T >::Begin();
- const ConstIterator endIter = Vector< T >::End();
- for ( ; iter != endIter; ++iter )
+ Iterator iter = Vector<T>::Begin();
+ const ConstIterator endIter = Vector<T>::End();
+ for(; iter != endIter; ++iter)
{
- if ( *iter == object )
+ if(*iter == object)
{
- Erase( iter );
+ Erase(iter);
return;
}
}
* @post iterators are invalidated by this method.
* @return pointer to the released item
*/
- T Release( Iterator position )
+ T Release(Iterator position)
{
T pointer = *position;
- Vector< T >::Erase( position );
+ Vector<T>::Erase(position);
return pointer;
}
*/
void Clear()
{
- ConstIterator end = Vector< T >::End();
- for( Iterator iter = Vector< T >::Begin(); iter != end; ++iter )
+ ConstIterator end = Vector<T>::End();
+ for(Iterator iter = Vector<T>::Begin(); iter != end; ++iter)
{
- Delete (*iter);
+ Delete(*iter);
}
- Vector< T >::Clear();
+ Vector<T>::Clear();
}
/**
* Resizes the container to hold specific amount of elements
* @param size to resize to
*/
- void Resize( SizeType size )
+ void Resize(SizeType size)
{
- if( size < VectorBase::Count() )
+ if(size < VectorBase::Count())
{
// OwnerContainer owns these heap-allocated objects
- ConstIterator end = Vector< T >::End();
- for( Iterator iter = Vector< T >::Begin() + size; iter != end; ++iter )
+ ConstIterator end = Vector<T>::End();
+ for(Iterator iter = Vector<T>::Begin() + size; iter != end; ++iter)
{
- Delete (*iter);
+ Delete(*iter);
}
}
- Vector< T >::Resize( size );
+ Vector<T>::Resize(size);
}
/**
* without deleting them. It will keep the original items here as well.
* @param[in] source where to move elements from to this OwnerContainer
*/
- void MoveFrom( OwnerContainer& source )
+ void MoveFrom(OwnerContainer& source)
{
- typename Vector< T >::SizeType sourceCount = source.Count();
+ typename Vector<T>::SizeType sourceCount = source.Count();
// if source is empty, nothing to move
- if( sourceCount > 0u )
+ if(sourceCount > 0u)
{
// Optimisation for the case that this is empty
- if( IsEmpty() )
+ if(IsEmpty())
{
- VectorBase::Swap( source );
+ VectorBase::Swap(source);
}
else
{
// make space for new items
- Vector< T >::Reserve( VectorBase::Count() + sourceCount );
- Iterator iter = source.Begin();
- ConstIterator end = source.End();
- for( ; iter != end; ++iter )
+ Vector<T>::Reserve(VectorBase::Count() + sourceCount);
+ Iterator iter = source.Begin();
+ ConstIterator end = source.End();
+ for(; iter != end; ++iter)
{
T pointer = *iter;
- Vector< T >::PushBack( pointer );
+ Vector<T>::PushBack(pointer);
}
// cannot call Clear on OwnerContainer as that deletes the elements
- source.Vector< T >::Clear();
+ source.Vector<T>::Clear();
}
}
}
private:
-
/**
* @brief delete the contents of the pointer
* Function provided to allow classes to provide a custom destructor through template specialisation
* @param pointer to the object
*/
- void Delete( T pointer )
+ void Delete(T pointer)
{
delete pointer;
}
-
-
};
} // namespace Dali
namespace Dali
{
-
/**
* @brief A reference counting wrapper for a vector class that allows
* a set of referencing smart pointers to collaborate in managing its
* stack.
* @tparam T type of the data that the vector holds
*/
-template< typename T >
+template<typename T>
class RefCountedVector : public RefObject
{
public:
*
* @return A reference to the vector that this object wraps.
*/
- Vector< T >& GetVector()
+ Vector<T>& GetVector()
{
return mVector;
}
// Not copyable or movable
- RefCountedVector( const RefCountedVector& ) = delete; ///< Deleted copy constructor
- RefCountedVector( RefCountedVector&& ) = delete; ///< Deleted move constructor
- RefCountedVector& operator=( const RefCountedVector& ) = delete; ///< Deleted copy assignment operator
- RefCountedVector& operator=( RefCountedVector&& ) = delete; ///< Deleted move assignment operator
+ RefCountedVector(const RefCountedVector&) = delete; ///< Deleted copy constructor
+ RefCountedVector(RefCountedVector&&) = delete; ///< Deleted move constructor
+ RefCountedVector& operator=(const RefCountedVector&) = delete; ///< Deleted copy assignment operator
+ RefCountedVector& operator=(RefCountedVector&&) = delete; ///< Deleted move assignment operator
protected:
virtual ~RefCountedVector()
}
private:
-
- Vector< T > mVector; ///< The vector of data
+ Vector<T> mVector; ///< The vector of data
};
} // namespace Dali
#define DALI_SET_WRAPPER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <set>
#undef _LIBCPP_INLINE_VISIBILITY
-#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
+#define _LIBCPP_INLINE_VISIBILITY __attribute__((__visibility__("hidden"), __always_inline__))
#undef _LIBCPP_EXTERN_TEMPLATE
#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
#include <bits/stl_tree.h>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ ("hidden")))
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ ("hidden")))
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__("hidden")))
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__("hidden")))
#include <set>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY`
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY`
#endif // #ifdef __clang__
namespace Dali
{
-
SingletonService::SingletonService()
{
}
{
}
-void SingletonService::Register( const std::type_info& info, BaseHandle singleton )
+void SingletonService::Register(const std::type_info& info, BaseHandle singleton)
{
- GetImplementation( *this ).Register( info, singleton );
+ GetImplementation(*this).Register(info, singleton);
}
void SingletonService::UnregisterAll()
{
- GetImplementation( *this ).UnregisterAll();
+ GetImplementation(*this).UnregisterAll();
}
-BaseHandle SingletonService::GetSingleton( const std::type_info& info ) const
+BaseHandle SingletonService::GetSingleton(const std::type_info& info) const
{
- return GetImplementation( *this ).GetSingleton( info );
+ return GetImplementation(*this).GetSingleton(info);
}
-SingletonService::SingletonService( Internal::ThreadLocalStorage* tls )
-: BaseHandle( tls )
+SingletonService::SingletonService(Internal::ThreadLocalStorage* tls)
+: BaseHandle(tls)
{
}
*/
// EXTERNAL INCLUDES
-#include <typeinfo>
#include <dali/public-api/object/base-handle.h>
+#include <typeinfo>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class ThreadLocalStorage;
class DALI_CORE_API SingletonService : public BaseHandle
{
public:
-
/**
* @brief Create an uninitialized handle.
*
* @param[in] info The type info of the Dali handle generated by the compiler.
* @param[in] singleton The Dali handle to be registered
*/
- void Register( const std::type_info& info, BaseHandle singleton );
+ void Register(const std::type_info& info, BaseHandle singleton);
/**
* @brief Unregisters all singletons.
* @param[in] info The type info of the given type.
* @return the Dali handle if it is registered as a singleton or an uninitialized handle.
*/
- BaseHandle GetSingleton( const std::type_info& info ) const;
+ BaseHandle GetSingleton(const std::type_info& info) const;
public: // Not intended for application developers
-
/**
* @brief This constructor is used by SingletonService::Get().
* @param[in] singletonService A pointer to the internal singleton-service object.
*/
- explicit DALI_INTERNAL SingletonService( Internal::ThreadLocalStorage* singletonService );
+ explicit DALI_INTERNAL SingletonService(Internal::ThreadLocalStorage* singletonService);
};
} // namespace Dali
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelStage
{
-
-KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage )
+KeyEventGeneratedSignalType& KeyEventGeneratedSignal(Dali::Stage stage)
{
- return GetImplementation( stage ).KeyEventGeneratedSignal();
+ return GetImplementation(stage).KeyEventGeneratedSignal();
}
-void SetRenderingBehavior( Dali::Stage stage, Rendering renderingBehavior )
+void SetRenderingBehavior(Dali::Stage stage, Rendering renderingBehavior)
{
- GetImplementation( stage ).SetRenderingBehavior( renderingBehavior );
+ GetImplementation(stage).SetRenderingBehavior(renderingBehavior);
}
-Rendering GetRenderingBehavior( Dali::Stage stage )
+Rendering GetRenderingBehavior(Dali::Stage stage)
{
- return GetImplementation( stage ).GetRenderingBehavior();
+ return GetImplementation(stage).GetRenderingBehavior();
}
-void AddFrameCallback( Dali::Stage stage, FrameCallbackInterface& frameCallback, Actor rootActor )
+void AddFrameCallback(Dali::Stage stage, FrameCallbackInterface& frameCallback, Actor rootActor)
{
- GetImplementation( stage ).AddFrameCallback( frameCallback, GetImplementation( rootActor ) );
+ GetImplementation(stage).AddFrameCallback(frameCallback, GetImplementation(rootActor));
}
-void RemoveFrameCallback( Dali::Stage stage, FrameCallbackInterface& frameCallback )
+void RemoveFrameCallback(Dali::Stage stage, FrameCallbackInterface& frameCallback)
{
- GetImplementation( stage ).RemoveFrameCallback( frameCallback );
+ GetImplementation(stage).RemoveFrameCallback(frameCallback);
}
} // namespace DevelStage
namespace Dali
{
-
class FrameCallbackInterface;
namespace DevelStage
{
-
/**
* @brief The DALi rendering behavior.
*/
CONTINUOUSLY, ///< Will render continuously.
};
-typedef Signal< bool (const KeyEvent&) > KeyEventGeneratedSignalType; ///< Stage key event generated signal type
+using KeyEventGeneratedSignalType = Signal<bool(const KeyEvent&)>; ///< Stage key event generated signal type
/**
* @brief The user would connect to this signal to get a KeyEvent when KeyEvent is generated.
* @param[in] stage The stage to emit a signal
* @return The return is true if KeyEvent is consumed, otherwise false.
*/
-DALI_CORE_API KeyEventGeneratedSignalType& KeyEventGeneratedSignal( Dali::Stage stage );
+DALI_CORE_API KeyEventGeneratedSignalType& KeyEventGeneratedSignal(Dali::Stage stage);
/**
* @brief Gives the user the ability to set the rendering behavior of DALi.
* @note By default, DALi uses Rendering::IF_REQUIRED.
* @see Rendering
*/
-DALI_CORE_API void SetRenderingBehavior( Dali::Stage stage, Rendering renderingBehavior );
+DALI_CORE_API void SetRenderingBehavior(Dali::Stage stage, Rendering renderingBehavior);
/**
* @brief Retrieves the rendering behavior of DALi.
* @param[in] stage The stage
* @return The rendering behavior of DALi.
*/
-DALI_CORE_API Rendering GetRenderingBehavior( Dali::Stage stage );
+DALI_CORE_API Rendering GetRenderingBehavior(Dali::Stage stage);
/*
* @brief The FrameCallbackInterface implementation added gets called on every frame from the update-thread.
* @note If the rootActor is destroyed, then the callback is automatically removed
* @see FrameCallbackInterface
*/
-DALI_CORE_API void AddFrameCallback( Dali::Stage stage, FrameCallbackInterface& frameCallback, Actor rootActor );
+DALI_CORE_API void AddFrameCallback(Dali::Stage stage, FrameCallbackInterface& frameCallback, Actor rootActor);
/**
* @brief Removes the specified FrameCallbackInterface implementation from being called on every frame.
* @note This function will block if the FrameCallbackInterface::Update method is being processed in the update-thread.
* @note If the callback implementation has already been removed, then this is a no-op.
*/
-DALI_CORE_API void RemoveFrameCallback( Dali::Stage stage, FrameCallbackInterface& frameCallback );
+DALI_CORE_API void RemoveFrameCallback(Dali::Stage stage, FrameCallbackInterface& frameCallback);
} // namespace DevelStage
#include <dali/devel-api/common/stage.h>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
-#include <dali/public-api/render-tasks/render-task-list.h>
-#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/common/core-impl.h>
+#include <dali/internal/event/common/stage-impl.h>
+#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/object/object-registry.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
namespace Dali
{
-
using Internal::Core;
Stage::Stage()
Stage Stage::GetCurrent()
{
Internal::Stage* stage = Internal::Stage::GetCurrent();
- DALI_ASSERT_ALWAYS( stage && "Stage doesn't exist" );
- return Stage( stage );
+ DALI_ASSERT_ALWAYS(stage && "Stage doesn't exist");
+ return Stage(stage);
}
bool Stage::IsInstalled()
RenderTaskList Stage::GetRenderTaskList() const
{
- return RenderTaskList( &GetImplementation(*this).GetRenderTaskList() );
+ return RenderTaskList(&GetImplementation(*this).GetRenderTaskList());
}
Vector2 Stage::GetSize() const
ObjectRegistry Stage::GetObjectRegistry() const
{
Internal::Stage* stage = Internal::Stage::GetCurrent();
- DALI_ASSERT_ALWAYS( stage && "GetObjectRegistry() : Stage is null" );
+ DALI_ASSERT_ALWAYS(stage && "GetObjectRegistry() : Stage is null");
Internal::ObjectRegistry& internal = stage->GetObjectRegistry();
return ObjectRegistry(&internal);
}
-void Stage::KeepRendering( float durationSeconds )
+void Stage::KeepRendering(float durationSeconds)
{
- GetImplementation(*this).KeepRendering( durationSeconds );
+ GetImplementation(*this).KeepRendering(durationSeconds);
}
Stage::KeyEventSignalType& Stage::KeyEventSignal()
Stage::TouchEventSignalType& Stage::TouchedSignal()
{
- return GetImplementation( *this ).TouchedSignal();
+ return GetImplementation(*this).TouchedSignal();
}
Stage::WheelEventSignalType& Stage::WheelEventSignal()
class DALI_CORE_API Stage : public BaseHandle
{
public:
-
- typedef Signal< void (const KeyEvent&) > KeyEventSignalType; ///< Key event signal type
- typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type
- typedef Signal< void (const TouchEvent&) > TouchEventSignalType; ///< Touch signal type
- typedef Signal< void (const WheelEvent&) > WheelEventSignalType; ///< Wheel signal type
- typedef Signal< void () > ContextStatusSignal; ///< Context status signal type
- typedef Signal< void () > SceneCreatedSignalType; ///< Scene created signal type
+ using KeyEventSignalType = Signal<void(const KeyEvent&)>; ///< Key event signal type
+ using EventProcessingFinishedSignalType = Signal<void()>; ///< Event Processing finished signal type
+ using TouchEventSignalType = Signal<void(const TouchEvent&)>; ///< Touch signal type
+ using WheelEventSignalType = Signal<void(const WheelEvent&)>; ///< Wheel signal type
+ using ContextStatusSignal = Signal<void()>; ///< Context status signal type
+ using SceneCreatedSignalType = Signal<void()>; ///< Scene created signal type
/**
* @brief Allows the creation of an empty stage handle.
* This method is useful to force screen refreshes e.g. when updating a NativeImage.
* @param[in] durationSeconds Time to keep rendering, 0 means render at least one more frame
*/
- void KeepRendering( float durationSeconds );
+ void KeepRendering(float durationSeconds);
// Signals
SceneCreatedSignalType& SceneCreatedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Stage::GetCurrent() methods.
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/devel-api/events/hit-test-algorithm.h>
// INTERNAL INCLUDES
-#include <dali/internal/event/events/hit-test-algorithm-impl.h>
-#include <dali/internal/event/common/stage-impl.h>
#include <dali/internal/event/common/scene-impl.h>
+#include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/event/events/hit-test-algorithm-impl.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
namespace Dali
{
-
namespace HitTestAlgorithm
{
-
-bool HitTest( Stage stage, const Vector2& screenCoordinates, Results& results, HitTestFunction func )
+bool HitTest(Stage stage, const Vector2& screenCoordinates, Results& results, HitTestFunction func)
{
- Internal::Stage& stageImpl = GetImplementation( stage );
- return Internal::HitTestAlgorithm::HitTest( stageImpl.GetSize(), stageImpl.GetRenderTaskList(), stageImpl.GetLayerList(), screenCoordinates, results, func );
+ Internal::Stage& stageImpl = GetImplementation(stage);
+ return Internal::HitTestAlgorithm::HitTest(stageImpl.GetSize(), stageImpl.GetRenderTaskList(), stageImpl.GetLayerList(), screenCoordinates, results, func);
}
} // namespace HitTestAlgorithm
-#ifndef __DALI_HIT_TEST_ALGORITHM_H__
-#define __DALI_HIT_TEST_ALGORITHM_H__
+#ifndef __DALI_HIT_TEST_ALGORITHM_H__
+#define __DALI_HIT_TEST_ALGORITHM_H__
/*
* Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
*/
-#include <dali/public-api/actors/actor.h>
#include <dali/devel-api/common/stage.h>
#include <dali/integration-api/scene.h>
-
+#include <dali/public-api/actors/actor.h>
namespace Dali
{
-
class RenderTask;
/**
*/
namespace HitTestAlgorithm
{
-
/**
* @brief How the actor tree should be traversed.
*/
enum TraverseType
{
- CHECK_ACTOR, ///< Hit test the given actor.
- DESCEND_ACTOR_TREE ///< Check whether the actor tree should be descended to hit-test its children.
+ CHECK_ACTOR, ///< Hit test the given actor.
+ DESCEND_ACTOR_TREE ///< Check whether the actor tree should be descended to hit-test its children.
};
/**
*/
struct Results
{
- Actor actor; ///< The hit actor.
- Vector2 actorCoordinates; ///< The actor coordinates.
+ Actor actor; ///< The hit actor.
+ Vector2 actorCoordinates; ///< The actor coordinates.
};
/**
*
* @return true, if the actor is hittable, false otherwise.
*/
-typedef bool (*HitTestFunction)(Actor actor, TraverseType type);
+using HitTestFunction = bool (*)(Actor, TraverseType);
/**
* @brief Given screen coordinates, this method returns the hit actor & the local coordinates relative to
* @param[in] func The function to use in the hit-test algorithm.
* @return true if something was hit
*/
-DALI_CORE_API bool HitTest( Stage stage, const Vector2& screenCoordinates, Results& results, HitTestFunction func );
+DALI_CORE_API bool HitTest(Stage stage, const Vector2& screenCoordinates, Results& results, HitTestFunction func);
} // namespace HitTestAlgorithm
\r
namespace Dali\r
{\r
-\r
namespace DevelHoverEvent\r
{\r
-\r
-HoverEvent New( uint32_t time )\r
+HoverEvent New(uint32_t time)\r
{\r
- return HoverEvent( new Internal::HoverEvent( time ) );\r
+ return HoverEvent(new Internal::HoverEvent(time));\r
}\r
\r
} // namespace DevelHoverEvent\r
\r
} // namespace Dali\r
-\r
\r
namespace Dali\r
{\r
-\r
namespace DevelHoverEvent\r
{\r
-\r
/**\r
* @brief Creates an initialized HoverEvent.\r
*\r
* @param[in] time The time the event occurred.\r
* @return A handle to a newly allocated Dali resource\r
*/\r
-DALI_CORE_API HoverEvent New( uint32_t time );\r
-\r
+DALI_CORE_API HoverEvent New(uint32_t time);\r
\r
} // namespace DevelHoverEvent\r
\r
\r
namespace Dali\r
{\r
-\r
namespace DevelKeyEvent\r
{\r
-\r
-KeyEvent New( const std::string& keyName,\r
- const std::string& logicalKey,\r
- const std::string& keyString,\r
- int keyCode,\r
- int keyModifier,\r
- unsigned long timeStamp,\r
- const Dali::KeyEvent::State& keyState,\r
- const std::string& compose,\r
- const std::string& deviceName,\r
- const Device::Class::Type deviceClass,\r
- const Device::Subclass::Type deviceSubclass )\r
+KeyEvent New(const std::string& keyName,\r
+ const std::string& logicalKey,\r
+ const std::string& keyString,\r
+ int keyCode,\r
+ int keyModifier,\r
+ unsigned long timeStamp,\r
+ const Dali::KeyEvent::State& keyState,\r
+ const std::string& compose,\r
+ const std::string& deviceName,\r
+ const Device::Class::Type deviceClass,\r
+ const Device::Subclass::Type deviceSubclass)\r
{\r
- Internal::KeyEventPtr internal = Internal::KeyEvent::New( keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass );\r
+ Internal::KeyEventPtr internal = Internal::KeyEvent::New(keyName, logicalKey, keyString, keyCode, keyModifier, timeStamp, keyState, compose, deviceName, deviceClass, deviceSubclass);\r
\r
- return KeyEvent( internal.Get() );\r
+ return KeyEvent(internal.Get());\r
}\r
\r
-void SetKeyName( KeyEvent keyEvent, const std::string& keyName )\r
+void SetKeyName(KeyEvent keyEvent, const std::string& keyName)\r
{\r
- GetImplementation( keyEvent ).SetKeyName( keyName );\r
+ GetImplementation(keyEvent).SetKeyName(keyName);\r
}\r
\r
-void SetKeyString( KeyEvent keyEvent, const std::string& keyString )\r
+void SetKeyString(KeyEvent keyEvent, const std::string& keyString)\r
{\r
- GetImplementation( keyEvent ).SetKeyString( keyString );\r
+ GetImplementation(keyEvent).SetKeyString(keyString);\r
}\r
\r
-void SetKeyCode( KeyEvent keyEvent, int32_t keyCode )\r
+void SetKeyCode(KeyEvent keyEvent, int32_t keyCode)\r
{\r
- GetImplementation( keyEvent ).SetKeyCode( keyCode );\r
+ GetImplementation(keyEvent).SetKeyCode(keyCode);\r
}\r
\r
-void SetKeyModifier( KeyEvent keyEvent, int32_t keyModifier )\r
+void SetKeyModifier(KeyEvent keyEvent, int32_t keyModifier)\r
{\r
- GetImplementation( keyEvent ).SetKeyModifier( keyModifier );\r
+ GetImplementation(keyEvent).SetKeyModifier(keyModifier);\r
}\r
\r
-void SetTime( KeyEvent keyEvent, unsigned long time )\r
+void SetTime(KeyEvent keyEvent, unsigned long time)\r
{\r
- GetImplementation( keyEvent ).SetTime( time );\r
+ GetImplementation(keyEvent).SetTime(time);\r
}\r
\r
-void SetState( KeyEvent keyEvent, const KeyEvent::State& state )\r
+void SetState(KeyEvent keyEvent, const KeyEvent::State& state)\r
{\r
- GetImplementation( keyEvent ).SetState( state );\r
+ GetImplementation(keyEvent).SetState(state);\r
}\r
\r
} // namespace DevelKeyEvent\r
\r
} // namespace Dali\r
-\r
\r
namespace Dali\r
{\r
-\r
namespace DevelKeyEvent\r
{\r
-\r
/**\r
- * @brief Creates an initialized WheelEvent.\r
+ * @brief Creates an initialized KeyEvent.\r
*\r
* @SINCE_1_9.27\r
* @param[in] keyName The name of the key pressed or command from the IMF, if later then the some following parameters will be needed.\r
* @param[in] deviceSubclass The subclass of device the key event originated from\r
* @return A handle to a newly allocated Dali resource\r
*/\r
-DALI_CORE_API KeyEvent New( const std::string& keyName,\r
- const std::string& logicalKey,\r
- const std::string& keyString,\r
- int keyCode,\r
- int keyModifier,\r
- unsigned long timeStamp,\r
- const Dali::KeyEvent::State& keyState,\r
- const std::string& compose,\r
- const std::string& deviceName,\r
- const Device::Class::Type deviceClass,\r
- const Device::Subclass::Type deviceSubclass );\r
+DALI_CORE_API KeyEvent New(const std::string& keyName,\r
+ const std::string& logicalKey,\r
+ const std::string& keyString,\r
+ int keyCode,\r
+ int keyModifier,\r
+ unsigned long timeStamp,\r
+ const Dali::KeyEvent::State& keyState,\r
+ const std::string& compose,\r
+ const std::string& deviceName,\r
+ const Device::Class::Type deviceClass,\r
+ const Device::Subclass::Type deviceSubclass);\r
\r
/**\r
* @brief Set the name given to the key pressed\r
* @param[in] keyEvent The instance of KeyEvent.\r
* @param[in] keyName The name given to the key pressed.\r
*/\r
-void SetKeyName( KeyEvent keyEvent, const std::string& keyName );\r
+DALI_CORE_API void SetKeyName(KeyEvent keyEvent, const std::string& keyName);\r
\r
/**\r
* @brief Set the actual string of input characters that should be used for input editors.\r
* @param[in] keyEvent The instance of KeyEvent.\r
* @param[in] keyString The actual string of input characters\r
*/\r
-void SetKeyString( KeyEvent keyEvent, const std::string& keyString );\r
+DALI_CORE_API void SetKeyString(KeyEvent keyEvent, const std::string& keyString);\r
\r
/**\r
* @brief Set the unique key code for the key pressed.\r
* @param[in] keyEvent The instance of KeyEvent.\r
* @param[in] keyCode The unique key code for the key pressed\r
*/\r
-void SetKeyCode( KeyEvent keyEvent, int32_t keyCode );\r
+DALI_CORE_API void SetKeyCode(KeyEvent keyEvent, int32_t keyCode);\r
\r
/**\r
* @brief Set the key modifier for special keys like Shift, Alt and Ctrl which modify the next key pressed.\r
* @param[in] keyEvent The instance of KeyEvent.\r
* @param[in] keyModifier The key modifier\r
*/\r
-void SetKeyModifier( KeyEvent keyEvent, int32_t keyModifier );\r
+DALI_CORE_API void SetKeyModifier(KeyEvent keyEvent, int32_t keyModifier);\r
\r
/**\r
* @brief Set the time (in ms) that the key event occurred.\r
* @param[in] keyEvent The instance of KeyEvent.\r
* @param[in] time The time (in ms)\r
*/\r
-void SetTime( KeyEvent keyEvent, unsigned long time );\r
+DALI_CORE_API void SetTime(KeyEvent keyEvent, unsigned long time);\r
\r
/**\r
* @brief Set the state of the key event.\r
* @param[in] keyEvent The instance of KeyEvent.\r
* @param[in] state The state of the key event\r
*/\r
-void SetState( KeyEvent keyEvent, const KeyEvent::State& state );\r
+DALI_CORE_API void SetState(KeyEvent keyEvent, const KeyEvent::State& state);\r
\r
} // namespace DevelKeyEvent\r
\r
namespace Dali
{
-
namespace DevelLongPressGestureDetector
{
-
-uint32_t GetMinimumHoldingTime( LongPressGestureDetector longPressGestureDetector )
+uint32_t GetMinimumHoldingTime(LongPressGestureDetector longPressGestureDetector)
{
- return GetImplementation( longPressGestureDetector ).GetMinimumHoldingTime();
+ return GetImplementation(longPressGestureDetector).GetMinimumHoldingTime();
}
-
} // namespace DevelLongPressGestureDetector
} // namespace Dali
-
namespace Dali
{
-
class LongPressGestureDetector;
namespace DevelLongPressGestureDetector
{
-
/**
* @brief Get the minimum holding time required to be recognized as a long press gesture in milliseconds
*
* @param[in] longPressGestureDetector The target LongPressGestureDetector instance
* @return The time value in milliseconds
*/
-DALI_CORE_API uint32_t GetMinimumHoldingTime( LongPressGestureDetector longPressGestureDetector );
+DALI_CORE_API uint32_t GetMinimumHoldingTime(LongPressGestureDetector longPressGestureDetector);
} // namespace DevelLongPressGestureDetector
--- /dev/null
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/devel-api/events/long-press-gesture-devel.h>\r
+#include <dali/internal/event/events/long-press-gesture/long-press-gesture-impl.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelLongPressGesture\r
+{\r
+LongPressGesture New(GestureState state)\r
+{\r
+ return LongPressGesture(new Internal::LongPressGesture(state));\r
+}\r
+\r
+} // namespace DevelLongPressGesture\r
+\r
+} // namespace Dali\r
--- /dev/null
+#ifndef DALI_LONG_PRESS_GESTURE_DEVEL_H\r
+#define DALI_LONG_PRESS_GESTURE_DEVEL_H\r
+\r
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/public-api/events/long-press-gesture.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelLongPressGesture\r
+{\r
+/**\r
+ * @brief Creates an initialized LongPressGesture.\r
+ *\r
+ * @param[in] state The state of the LongPressGesture\r
+ * @return A handle to a newly allocated Dali resource\r
+ */\r
+DALI_CORE_API LongPressGesture New(GestureState state);\r
+\r
+} // namespace DevelLongPressGesture\r
+\r
+} // namespace Dali\r
+\r
+#endif // DALI_LONG_PRESS_GESTURE_DEVEL_H\r
// INTERNAL INCLUDES
#include <dali/internal/event/events/pan-gesture/pan-gesture-impl.h>
-
namespace Dali
{
-
namespace DevelPanGesture
{
-
-Dali::PanGesture New( GestureState state )
+Dali::PanGesture New(GestureState state)
{
- return PanGesture( new Internal::PanGesture( state ) );
+ return PanGesture(new Internal::PanGesture(state));
}
-void SetTime( Dali::PanGesture& gesture, uint32_t time )
+void SetTime(Dali::PanGesture& gesture, uint32_t time)
{
- GetImplementation( gesture ).SetTime( time );
+ GetImplementation(gesture).SetTime(time);
}
-void SetVelocity( Dali::PanGesture& gesture, const Vector2& velocity)
+void SetVelocity(Dali::PanGesture& gesture, const Vector2& velocity)
{
- GetImplementation( gesture ).SetVelocity( velocity );
+ GetImplementation(gesture).SetVelocity(velocity);
}
-void SetDisplacement( Dali::PanGesture& gesture, const Vector2& displacement)
+void SetDisplacement(Dali::PanGesture& gesture, const Vector2& displacement)
{
- GetImplementation( gesture ).SetDisplacement( displacement );
+ GetImplementation(gesture).SetDisplacement(displacement);
}
-void SetPosition( Dali::PanGesture& gesture, const Vector2& position)
+void SetPosition(Dali::PanGesture& gesture, const Vector2& position)
{
- GetImplementation( gesture ).SetPosition( position );
+ GetImplementation(gesture).SetPosition(position);
}
-void SetScreenVelocity( Dali::PanGesture& gesture, const Vector2& screenVelocity)
+void SetScreenVelocity(Dali::PanGesture& gesture, const Vector2& screenVelocity)
{
- GetImplementation( gesture ).SetScreenVelocity( screenVelocity );
+ GetImplementation(gesture).SetScreenVelocity(screenVelocity);
}
-void SetScreenDisplacement( Dali::PanGesture& gesture, const Vector2& screenDisplacement)
+void SetScreenDisplacement(Dali::PanGesture& gesture, const Vector2& screenDisplacement)
{
- GetImplementation( gesture ).SetScreenDisplacement( screenDisplacement );
+ GetImplementation(gesture).SetScreenDisplacement(screenDisplacement);
}
-void SetScreenPosition( Dali::PanGesture& gesture, const Vector2& screenPosition)
+void SetScreenPosition(Dali::PanGesture& gesture, const Vector2& screenPosition)
{
- GetImplementation( gesture ).SetScreenPosition( screenPosition );
+ GetImplementation(gesture).SetScreenPosition(screenPosition);
}
-void SetNumberOfTouches( Dali::PanGesture& gesture, uint32_t numberOfTouches )
+void SetNumberOfTouches(Dali::PanGesture& gesture, uint32_t numberOfTouches)
{
- GetImplementation( gesture ).SetNumberOfTouches( numberOfTouches );
+ GetImplementation(gesture).SetNumberOfTouches(numberOfTouches);
}
} // namespace DevelPanGesture
namespace Dali
{
-
namespace DevelPanGesture
{
-
/**
* @brief Create a PanGeture for internal.
* @param[in] state The state of the PanGesture
--- /dev/null
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/devel-api/events/pinch-gesture-devel.h>\r
+#include <dali/internal/event/events/pinch-gesture/pinch-gesture-impl.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelPinchGesture\r
+{\r
+PinchGesture New(GestureState state)\r
+{\r
+ return PinchGesture(new Internal::PinchGesture(state));\r
+}\r
+\r
+} // namespace DevelPinchGesture\r
+\r
+} // namespace Dali\r
--- /dev/null
+#ifndef DALI_PINCH_GESTURE_DEVEL_H\r
+#define DALI_PINCH_GESTURE_DEVEL_H\r
+\r
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/public-api/events/pinch-gesture.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelPinchGesture\r
+{\r
+/**\r
+ * @brief Creates an initialized PinchGesture.\r
+ *\r
+ * @param[in] state The state of the PinchGesture\r
+ * @return A handle to a newly allocated Dali resource\r
+ */\r
+DALI_CORE_API PinchGesture New(GestureState state);\r
+\r
+} // namespace DevelPinchGesture\r
+\r
+} // namespace Dali\r
+\r
+#endif // DALI_PINCH_GESTURE_DEVEL_H\r
--- /dev/null
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/devel-api/events/rotation-gesture-devel.h>\r
+#include <dali/internal/event/events/rotation-gesture/rotation-gesture-impl.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelRotationGesture\r
+{\r
+RotationGesture New(GestureState state)\r
+{\r
+ return RotationGesture(new Internal::RotationGesture(state));\r
+}\r
+\r
+} // namespace DevelRotationGesture\r
+\r
+} // namespace Dali\r
--- /dev/null
+#ifndef DALI_ROTATION_GESTURE_DEVEL_H\r
+#define DALI_ROTATION_GESTURE_DEVEL_H\r
+\r
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/public-api/events/rotation-gesture.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelRotationGesture\r
+{\r
+/**\r
+ * @brief Creates an initialized RotationGesture.\r
+ *\r
+ * @param[in] state The state of the RotationGesture\r
+ * @return A handle to a newly allocated Dali resource\r
+ */\r
+DALI_CORE_API RotationGesture New(GestureState state);\r
+\r
+} // namespace DevelRotationGesture\r
+\r
+} // namespace Dali\r
+\r
+#endif // DALI_ROTATION_GESTURE_DEVEL_H\r
-/*
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-// CLASS HEADER
-#include <dali/internal/common/internal-constants.h>
-
-namespace Dali
-{
-
-const float Internal::FULLY_OPAQUE = 0.99f;
-const float Internal::FULLY_TRANSPARENT = 0.01f;
-
-} // namespace Dali
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/devel-api/events/tap-gesture-devel.h>\r
+#include <dali/internal/event/events/tap-gesture/tap-gesture-impl.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelTapGesture\r
+{\r
+TapGesture New(GestureState state)\r
+{\r
+ return TapGesture(new Internal::TapGesture(state));\r
+}\r
+\r
+} // namespace DevelTapGesture\r
+\r
+} // namespace Dali\r
--- /dev/null
+#ifndef DALI_TAP_GESTURE_DEVEL_H\r
+#define DALI_TAP_GESTURE_DEVEL_H\r
+\r
+/*\r
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.\r
+ *\r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ *\r
+ */\r
+\r
+// INTERNAL INCLUDES\r
+#include <dali/public-api/events/tap-gesture.h>\r
+\r
+namespace Dali\r
+{\r
+namespace DevelTapGesture\r
+{\r
+/**\r
+ * @brief Creates an initialized TapGesture.\r
+ *\r
+ * @param[in] state The state of the TapGesture\r
+ * @return A handle to a newly allocated Dali resource\r
+ */\r
+DALI_CORE_API TapGesture New(GestureState state);\r
+\r
+} // namespace DevelTapGesture\r
+\r
+} // namespace Dali\r
+\r
+#endif // DALI_TAP_GESTURE_DEVEL_H\r
namespace Dali
{
-
TouchPoint::TouchPoint(int32_t id, PointState::Type state, float screenX, float screenY)
: deviceId(id),
state(state),
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/actors/actor.h>
+#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/events/point-state.h>
#include <dali/public-api/math/vector2.h>
Vector2 screen;
};
-typedef std::vector<TouchPoint> TouchPointContainer; ///< Container of touch points. @SINCE_1_0.0
-typedef TouchPointContainer::iterator TouchPointContainerIterator; ///< Iterator for Dali::TouchPointContainer @SINCE_1_0.0
-typedef TouchPointContainer::const_iterator TouchPointContainerConstIterator; ///< Const iterator for Dali::TouchPointContainer @SINCE_1_0.0
+using TouchPointContainer = std::vector<TouchPoint>; ///< Container of touch points. @SINCE_1_0.0
+using TouchPointContainerIterator = TouchPointContainer::iterator; ///< Iterator for Dali::TouchPointContainer @SINCE_1_0.0
+using TouchPointContainerConstIterator = TouchPointContainer::const_iterator; ///< Const iterator for Dali::TouchPointContainer @SINCE_1_0.0
/**
* @}
\r
namespace Dali\r
{\r
-\r
namespace DevelWheelEvent\r
{\r
-\r
-WheelEvent New( WheelEvent::Type type, int32_t direction, uint32_t modifiers, Vector2 point, int32_t delta, uint32_t timeStamp )\r
+WheelEvent New(WheelEvent::Type type, int32_t direction, uint32_t modifiers, Vector2 point, int32_t delta, uint32_t timeStamp)\r
{\r
- Internal::WheelEventPtr internal = Internal::WheelEvent::New( type, direction, modifiers, point, delta, timeStamp );\r
+ Internal::WheelEventPtr internal = Internal::WheelEvent::New(type, direction, modifiers, point, delta, timeStamp);\r
\r
- return WheelEvent( internal.Get() );\r
+ return WheelEvent(internal.Get());\r
}\r
\r
-} // namespace DevelKeyEvent\r
+} // namespace DevelWheelEvent\r
\r
} // namespace Dali\r
-\r
\r
namespace Dali\r
{\r
-\r
namespace DevelWheelEvent\r
{\r
-\r
/**\r
* @brief Creates an initialized WheelEvent.\r
*\r
* @param[in] timeStamp The time the wheel is being rolled\r
* @return A handle to a newly allocated Dali resource\r
*/\r
-DALI_CORE_API WheelEvent New( WheelEvent::Type type, int32_t direction, uint32_t modifiers, Vector2 point, int32_t delta, uint32_t timeStamp );\r
-\r
+DALI_CORE_API WheelEvent New(WheelEvent::Type type, int32_t direction, uint32_t modifiers, Vector2 point, int32_t delta, uint32_t timeStamp);\r
\r
} // namespace DevelWheelEvent\r
\r
${devel_api_src_dir}/events/hit-test-algorithm.cpp
${devel_api_src_dir}/events/hover-event-devel.cpp
${devel_api_src_dir}/events/key-event-devel.cpp
+ ${devel_api_src_dir}/events/long-press-gesture-devel.cpp
${devel_api_src_dir}/events/long-press-gesture-detector-devel.cpp
${devel_api_src_dir}/events/pan-gesture-devel.cpp
+ ${devel_api_src_dir}/events/pinch-gesture-devel.cpp
+ ${devel_api_src_dir}/events/rotation-gesture-devel.cpp
+ ${devel_api_src_dir}/events/tap-gesture-devel.cpp
${devel_api_src_dir}/events/touch-point.cpp
${devel_api_src_dir}/events/wheel-event-devel.cpp
${devel_api_src_dir}/images/distance-field.cpp
${devel_api_src_dir}/object/csharp-type-registry.cpp
${devel_api_src_dir}/rendering/frame-buffer-devel.cpp
${devel_api_src_dir}/rendering/renderer-devel.cpp
+ ${devel_api_src_dir}/rendering/texture-devel.cpp
${devel_api_src_dir}/scripting/scripting.cpp
${devel_api_src_dir}/signals/signal-delegate.cpp
${devel_api_src_dir}/threading/conditional-wait.cpp
${devel_api_src_dir}/events/hit-test-algorithm.h
${devel_api_src_dir}/events/hover-event-devel.h
${devel_api_src_dir}/events/key-event-devel.h
+ ${devel_api_src_dir}/events/long-press-gesture-devel.h
${devel_api_src_dir}/events/long-press-gesture-detector-devel.h
${devel_api_src_dir}/events/pan-gesture-devel.h
+ ${devel_api_src_dir}/events/pinch-gesture-devel.h
+ ${devel_api_src_dir}/events/rotation-gesture-devel.h
+ ${devel_api_src_dir}/events/tap-gesture-devel.h
${devel_api_src_dir}/events/touch-point.h
${devel_api_src_dir}/events/wheel-event-devel.h
)
SET( devel_api_core_rendering_header_files
${devel_api_src_dir}/rendering/frame-buffer-devel.h
${devel_api_src_dir}/rendering/renderer-devel.h
+ ${devel_api_src_dir}/rendering/texture-devel.h
)
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/devel-api/images/distance-field.h>
// EXTERNAL INCLUDES
-#include <algorithm>
#include <math.h>
#include <stdio.h>
#include <time.h>
+#include <algorithm>
// INTERNAL INCLUDES
#include <dali/public-api/common/constants.h>
#include <dali/public-api/common/vector-wrapper.h>
-#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/math-utils.h>
+#include <dali/public-api/math/vector2.h>
namespace Dali
{
-
namespace
{
-
-float Interpolate( float a, float b, float factor )
+float Interpolate(float a, float b, float factor)
{
return a * (1.0f - factor) + b * factor;
}
-float Bilinear( float a, float b, float c, float d, float dx, float dy )
+float Bilinear(float a, float b, float c, float d, float dx, float dy)
{
- return Interpolate( Interpolate( a, b, dx), Interpolate( c, d, dx ), dy );
+ return Interpolate(Interpolate(a, b, dx), Interpolate(c, d, dx), dy);
}
-void ScaleField( int width, int height, float* in, uint32_t targetWidth, uint32_t targetHeight, float* out )
+void ScaleField(int width, int height, float* in, uint32_t targetWidth, uint32_t targetHeight, float* out)
{
- float xScale = static_cast<float>( width ) / static_cast<float>( targetWidth );
- float yScale = static_cast<float>( height ) / static_cast<float>( targetHeight );
+ float xScale = static_cast<float>(width) / static_cast<float>(targetWidth);
+ float yScale = static_cast<float>(height) / static_cast<float>(targetHeight);
// for each row in target
for(uint32_t y = 0; y < targetHeight; ++y)
{
- const int32_t sampleY = static_cast< int32_t >( yScale * static_cast<float>( y ) );
- const int32_t otherY = std::min( sampleY + 1, height - 1 );
- const float dy = (yScale * static_cast<float>( y ) ) - static_cast<float>( sampleY );
+ const int32_t sampleY = static_cast<int32_t>(yScale * static_cast<float>(y));
+ const int32_t otherY = std::min(sampleY + 1, height - 1);
+ const float dy = (yScale * static_cast<float>(y)) - static_cast<float>(sampleY);
// for each column in target
- for (uint32_t x = 0; x < targetWidth; ++x)
+ for(uint32_t x = 0; x < targetWidth; ++x)
{
- const int32_t sampleX = static_cast< int32_t >( xScale * static_cast<float>( x ) );
- const int32_t otherX = std::min( sampleX + 1, width - 1 );
- const float dx = (xScale * static_cast<float>( x ) ) - static_cast<float>( sampleX );
-
- float value = Bilinear( in[ sampleY * width + sampleX ],
- in[ sampleY * width + otherX ],
- in[ otherY * width + sampleX ],
- in[ otherY * width + otherX ],
- dx, dy );
-
- out[y * targetWidth + x] = std::min( value, 1.0f );
+ const int32_t sampleX = static_cast<int32_t>(xScale * static_cast<float>(x));
+ const int32_t otherX = std::min(sampleX + 1, width - 1);
+ const float dx = (xScale * static_cast<float>(x)) - static_cast<float>(sampleX);
+
+ float value = Bilinear(in[sampleY * width + sampleX],
+ in[sampleY * width + otherX],
+ in[otherY * width + sampleX],
+ in[otherY * width + otherX],
+ dx,
+ dy);
+
+ out[y * targetWidth + x] = std::min(value, 1.0f);
}
}
}
#define SQUARE(a) ((a) * (a))
-const float MAX_DISTANCE = static_cast<float>( 1e20 );
+const float MAX_DISTANCE = static_cast<float>(1e20);
/**
* Distance transform of 1D function using squared distance
*/
-void DistanceTransform( float *source, float* dest, uint32_t length )
+void DistanceTransform(float* source, float* dest, uint32_t length)
{
- std::vector<int32_t> parabolas(length); // Locations of parabolas in lower envelope
- std::vector<float> edge(length + 1); // Locations of boundaries between parabolas
+ std::vector<int32_t> parabolas(length); // Locations of parabolas in lower envelope
+ std::vector<float> edge(length + 1); // Locations of boundaries between parabolas
- int32_t rightmost(0); // Index of rightmost parabola in lower envelope
+ int32_t rightmost(0); // Index of rightmost parabola in lower envelope
parabolas[0] = 0;
- edge[0] = -MAX_DISTANCE;
- edge[1] = +MAX_DISTANCE;
- for( uint32_t i = 1; i <= length - 1; i++ )
+ edge[0] = -MAX_DISTANCE;
+ edge[1] = +MAX_DISTANCE;
+ for(uint32_t i = 1; i <= length - 1; i++)
{
- const float initialDistance( source[i] + static_cast<float>( i*i ) );
- int32_t parabola = parabolas[rightmost];
- float newDistance( (initialDistance - (source[parabola] + static_cast<float>( parabola * parabola ))) / static_cast<float>(2 * i - 2 * parabola) );
- while( rightmost > 0 && newDistance <= edge[rightmost] )
+ const float initialDistance(source[i] + static_cast<float>(i * i));
+ int32_t parabola = parabolas[rightmost];
+
+ float newDistance((initialDistance - (source[parabola] + static_cast<float>(parabola * parabola))) / static_cast<float>(2 * i - 2 * parabola));
+
+ while(rightmost > 0 && newDistance <= edge[rightmost])
{
rightmost--;
- parabola = parabolas[rightmost];
- newDistance = (initialDistance - (source[parabola] + static_cast<float>( parabola * parabola ))) / static_cast<float>(2 * i - 2 * parabola);
+ parabola = parabolas[rightmost];
+ newDistance = (initialDistance - (source[parabola] + static_cast<float>(parabola * parabola))) / static_cast<float>(2 * i - 2 * parabola);
}
rightmost++;
parabolas[rightmost] = i;
- edge[rightmost] = newDistance;
- edge[rightmost + 1] = MAX_DISTANCE;
+ edge[rightmost] = newDistance;
+ edge[rightmost + 1] = MAX_DISTANCE;
}
rightmost = 0;
- for( uint32_t i = 0; i <= length - 1; ++i )
+ for(uint32_t i = 0; i <= length - 1; ++i)
{
- while( edge[rightmost + 1] < static_cast<float>( i ) )
+ while(edge[rightmost + 1] < static_cast<float>(i))
{
++rightmost;
}
- dest[i] = static_cast<float>( SQUARE( static_cast< int32_t >( i ) - parabolas[rightmost] ) ) + source[parabolas[rightmost]];
+ dest[i] = static_cast<float>(SQUARE(static_cast<int32_t>(i) - parabolas[rightmost])) + source[parabolas[rightmost]];
}
}
/**
* Distance transform of 2D function using squared distance
*/
-void DistanceTransform( float* data, uint32_t width, uint32_t height, float* sourceBuffer, float* destBuffer )
+void DistanceTransform(float* data, uint32_t width, uint32_t height, float* sourceBuffer, float* destBuffer)
{
// transform along columns
- for( uint32_t x = 0; x < width; ++x )
+ for(uint32_t x = 0; x < width; ++x)
{
- for( uint32_t y = 0; y < height; ++y )
+ for(uint32_t y = 0; y < height; ++y)
{
- sourceBuffer[y] = data[ y * width + x ];
+ sourceBuffer[y] = data[y * width + x];
}
- DistanceTransform( sourceBuffer, destBuffer, height );
+ DistanceTransform(sourceBuffer, destBuffer, height);
- for( uint32_t y = 0; y < height; y++ )
+ for(uint32_t y = 0; y < height; y++)
{
data[y * width + x] = destBuffer[y];
}
}
// transform along rows
- for( uint32_t y = 0; y < height; ++y )
+ for(uint32_t y = 0; y < height; ++y)
{
- for( uint32_t x = 0; x < width; ++x )
+ for(uint32_t x = 0; x < width; ++x)
{
- sourceBuffer[x] = data[ y * width + x ];
+ sourceBuffer[x] = data[y * width + x];
}
- DistanceTransform( sourceBuffer, destBuffer, width );
+ DistanceTransform(sourceBuffer, destBuffer, width);
- for( uint32_t x = 0; x < width; x++ )
+ for(uint32_t x = 0; x < width; x++)
{
data[y * width + x] = destBuffer[x];
}
} // namespace
-void GenerateDistanceFieldMap(const uint8_t* const imagePixels, const Size& imageSize,
- uint8_t* const distanceMap, const Size& distanceMapSize,
- const float fieldRadius, const uint32_t fieldBorder, bool highQuality)
+void GenerateDistanceFieldMap(const uint8_t* const imagePixels, const Size& imageSize, uint8_t* const distanceMap, const Size& distanceMapSize, const float fieldRadius, const uint32_t fieldBorder, bool highQuality)
{
- GenerateDistanceFieldMap( imagePixels, imageSize, distanceMap, distanceMapSize, fieldBorder, imageSize, highQuality );
+ GenerateDistanceFieldMap(imagePixels, imageSize, distanceMap, distanceMapSize, fieldBorder, imageSize, highQuality);
}
-void GenerateDistanceFieldMap( const uint8_t* const imagePixels, const Size& imageSize,
- uint8_t* const distanceMap, const Size& distanceMapSize,
- const uint32_t fieldBorder,
- const Vector2& maxSize,
- bool highQuality )
+void GenerateDistanceFieldMap(const uint8_t* const imagePixels, const Size& imageSize, uint8_t* const distanceMap, const Size& distanceMapSize, const uint32_t fieldBorder, const Vector2& maxSize, bool highQuality)
{
// constants to reduce redundant calculations
- const uint32_t originalWidth( static_cast<int32_t>(imageSize.width) );
- const uint32_t originalHeight( static_cast<int32_t>(imageSize.height) );
- const uint32_t paddedWidth( originalWidth + (fieldBorder * 2 ) );
- const uint32_t paddedHeight( originalHeight + (fieldBorder * 2 ) );
- const uint32_t scaledWidth( static_cast<int32_t>(distanceMapSize.width) );
- const uint32_t scaledHeight( static_cast<int32_t>(distanceMapSize.height) );
- const uint32_t maxWidth( static_cast<int32_t>(maxSize.width) + (fieldBorder * 2 ));
- const uint32_t maxHeight( static_cast<int32_t>(maxSize.height) + (fieldBorder * 2 ) );
+ const uint32_t originalWidth(static_cast<int32_t>(imageSize.width));
+ const uint32_t originalHeight(static_cast<int32_t>(imageSize.height));
+ const uint32_t paddedWidth(originalWidth + (fieldBorder * 2));
+ const uint32_t paddedHeight(originalHeight + (fieldBorder * 2));
+ const uint32_t scaledWidth(static_cast<int32_t>(distanceMapSize.width));
+ const uint32_t scaledHeight(static_cast<int32_t>(distanceMapSize.height));
+ const uint32_t maxWidth(static_cast<int32_t>(maxSize.width) + (fieldBorder * 2));
+ const uint32_t maxHeight(static_cast<int32_t>(maxSize.height) + (fieldBorder * 2));
- const uint32_t bufferLength( std::max( maxWidth, std::max(paddedWidth, scaledWidth) ) *
- std::max( maxHeight, std::max(paddedHeight, scaledHeight) ) );
+ const uint32_t bufferLength(std::max(maxWidth, std::max(paddedWidth, scaledWidth)) *
+ std::max(maxHeight, std::max(paddedHeight, scaledHeight)));
- std::vector<float> outsidePixels( bufferLength, 0.0f );
- std::vector<float> insidePixels( bufferLength, 0.0f );
+ std::vector<float> outsidePixels(bufferLength, 0.0f);
+ std::vector<float> insidePixels(bufferLength, 0.0f);
- float* outside( outsidePixels.data() );
- float* inside( insidePixels.data() );
+ float* outside(outsidePixels.data());
+ float* inside(insidePixels.data());
- for( uint32_t y = 0; y < paddedHeight; ++y )
+ for(uint32_t y = 0; y < paddedHeight; ++y)
{
- for ( uint32_t x = 0; x < paddedWidth; ++x)
+ for(uint32_t x = 0; x < paddedWidth; ++x)
{
- if( y < static_cast< uint32_t >( fieldBorder ) || y >= ( paddedHeight - static_cast< uint32_t >( fieldBorder ) ) ||
- x < static_cast< uint32_t >( fieldBorder ) || x >= ( paddedWidth - static_cast< uint32_t >( fieldBorder ) ) )
+ if(y < static_cast<uint32_t>(fieldBorder) ||
+ y >= (paddedHeight - static_cast<uint32_t>(fieldBorder)) ||
+ x < static_cast<uint32_t>(fieldBorder) ||
+ x >= (paddedWidth - static_cast<uint32_t>(fieldBorder)))
{
- outside[ y * paddedWidth + x ] = MAX_DISTANCE;
- inside[ y * paddedWidth + x ] = 0.0f;
+ outside[y * paddedWidth + x] = MAX_DISTANCE;
+ inside[y * paddedWidth + x] = 0.0f;
}
else
{
- uint32_t pixel( imagePixels[ (y - fieldBorder) * originalWidth + (x - fieldBorder) ] );
- outside[ y * paddedWidth + x ] = (pixel == 0) ? MAX_DISTANCE : SQUARE( static_cast<float>(255 - pixel) / 255.0f);
- inside[ y * paddedWidth + x ] = (pixel == 255) ? MAX_DISTANCE : SQUARE( static_cast<float>(pixel) / 255.0f);
+ uint32_t pixel(imagePixels[(y - fieldBorder) * originalWidth + (x - fieldBorder)]);
+ outside[y * paddedWidth + x] = (pixel == 0) ? MAX_DISTANCE : SQUARE(static_cast<float>(255 - pixel) / 255.0f);
+ inside[y * paddedWidth + x] = (pixel == 255) ? MAX_DISTANCE : SQUARE(static_cast<float>(pixel) / 255.0f);
}
}
}
// perform distance transform if high quality requested, else use original figure
- if( highQuality )
+ if(highQuality)
{
// create temporary buffers for DistanceTransform()
- const uint32_t tempBufferLength( std::max(paddedWidth, paddedHeight) );
- std::vector<float> tempSourceBuffer( tempBufferLength, 0.0f );
- std::vector<float> tempDestBuffer( tempBufferLength, 0.0f );
+ const uint32_t tempBufferLength(std::max(paddedWidth, paddedHeight));
+ std::vector<float> tempSourceBuffer(tempBufferLength, 0.0f);
+ std::vector<float> tempDestBuffer(tempBufferLength, 0.0f);
// Perform distance transform for pixels 'outside' the figure
- DistanceTransform( outside, paddedWidth, paddedHeight, tempSourceBuffer.data(), tempDestBuffer.data() );
+ DistanceTransform(outside, paddedWidth, paddedHeight, tempSourceBuffer.data(), tempDestBuffer.data());
// Perform distance transform for pixels 'inside' the figure
- DistanceTransform( inside, paddedWidth, paddedHeight, tempSourceBuffer.data(), tempDestBuffer.data() );
+ DistanceTransform(inside, paddedWidth, paddedHeight, tempSourceBuffer.data(), tempDestBuffer.data());
}
// distmap = outside - inside; % Bipolar distance field
- for( uint32_t y = 0; y < paddedHeight; ++y)
+ for(uint32_t y = 0; y < paddedHeight; ++y)
{
- for( uint32_t x = 0; x < paddedWidth; ++x )
+ for(uint32_t x = 0; x < paddedWidth; ++x)
{
- const int32_t offset( y * paddedWidth + x );
- float pixel( sqrtf(outside[offset]) - sqrtf(inside[offset]) );
- pixel = 128.0f + pixel * 16.0f;
- pixel = Clamp( pixel, 0.0f, 255.0f );
+ const int32_t offset(y * paddedWidth + x);
+ float pixel(sqrtf(outside[offset]) - sqrtf(inside[offset]));
+ pixel = 128.0f + pixel * 16.0f;
+ pixel = Clamp(pixel, 0.0f, 255.0f);
outside[offset] = (255.0f - pixel) / 255.0f;
}
}
// scale the figure to the distance field tile size
- ScaleField( paddedWidth, paddedHeight, outside, scaledWidth, scaledHeight, inside );
+ ScaleField(paddedWidth, paddedHeight, outside, scaledWidth, scaledHeight, inside);
// convert from floats to integers
- for( uint32_t y = 0; y < scaledHeight; ++y )
+ for(uint32_t y = 0; y < scaledHeight; ++y)
{
- for( uint32_t x = 0; x < scaledWidth; ++x )
+ for(uint32_t x = 0; x < scaledWidth; ++x)
{
- float pixel( inside[ y * scaledWidth + x ] );
- distanceMap[y * scaledWidth + x ] = static_cast< uint8_t >(pixel * 255.0f);
+ float pixel(inside[y * scaledWidth + x]);
+ distanceMap[y * scaledWidth + x] = static_cast<uint8_t>(pixel * 255.0f);
}
}
}
#define DALI_DISTANCE_FIELD_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
struct Vector2;
/**
* @param[in] maxSize The image is scaled from this size to distanceMapSize
* @param[in] highQuality Set true to generate high quality distance fields
*/
-DALI_CORE_API void GenerateDistanceFieldMap( const uint8_t* const imagePixels, const Vector2& imageSize,
- uint8_t* const distanceMap, const Vector2& distanceMapSize,
- const uint32_t fieldBorder,
- const Vector2& maxSize,
- bool highQuality = true );
+DALI_CORE_API void GenerateDistanceFieldMap(
+ const uint8_t* const imagePixels,
+ const Vector2& imageSize,
+ uint8_t* const distanceMap,
+ const Vector2& distanceMapSize,
+ const uint32_t fieldBorder,
+ const Vector2& maxSize,
+ bool highQuality = true);
} //namespace Dali
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelPixelData
{
-
-PixelDataBuffer ReleasePixelDataBuffer( PixelData& pixelData )
+PixelDataBuffer ReleasePixelDataBuffer(PixelData& pixelData)
{
- Internal::PixelData& pixelDataImpl = GetImplementation( pixelData );
- PixelDataBuffer pixelDataBuffer = pixelDataImpl.ReleaseBuffer();
+ Internal::PixelData& pixelDataImpl = GetImplementation(pixelData);
+ PixelDataBuffer pixelDataBuffer = pixelDataImpl.ReleaseBuffer();
pixelData.Reset();
return pixelDataBuffer;
}
#define DALI_PIXEL_DATA_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelPixelData
{
-
/**
* Struct to keep the buffer pointer and the allocation method.
*
*/
struct PixelDataBuffer
{
- uint8_t* buffer;
- uint32_t bufferSize;
+ uint8_t* buffer;
+ uint32_t bufferSize;
PixelData::ReleaseFunction releaseFunction;
- PixelDataBuffer( uint8_t* buffer,
- uint32_t bufferSize,
- PixelData::ReleaseFunction releaseFunction )
+ PixelDataBuffer(uint8_t* buffer,
+ uint32_t bufferSize,
+ PixelData::ReleaseFunction releaseFunction)
: buffer(buffer),
bufferSize(bufferSize),
releaseFunction(releaseFunction)
* @param[in,out] pixelData The pixel data object to take the buffer from
* @return the buffer and the data release mechanism
*/
-DALI_CORE_API PixelDataBuffer ReleasePixelDataBuffer( PixelData& pixelData );
+DALI_CORE_API PixelDataBuffer ReleasePixelDataBuffer(PixelData& pixelData);
} // namespace DevelPixelData
-} // Dali
+} // namespace Dali
#endif // DALI_PIXEL_DATA_DEVEL_H
#define DALI_CSHARP_TYPE_INFO_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace CSharpTypeInfo
{
+/**
+ * @brief Call back used to create an instance of the associated object type
+ *
+ * @param[in] typeName The type name of the object to be created.
+ * @return Pointer to a BaseHandle
+ */
+using CreateFunction = BaseHandle* (*)(const char* const);
- /**
- * @brief Call back used to create an instance of the associated object type
- *
- * @param[in] typeName The type name of the object to be created.
- * @return Pointer to a BaseHandle
- */
- typedef BaseHandle* (*CreateFunction)(const char* const typeName);
-
- /**
- * @brief Callback to set an event-thread only property.
- *
- * @param[in] object The object whose property should be set.
- * @param[in] propertyName The name of the property required.
- * @param[in] value The new value of the property for the object specified.
- * @see PropertyRegistration.
- */
- typedef void (*SetPropertyFunction)( BaseObject* object, const char* const propertyName , Property::Value* value );
-
-
- /**
- * @brief Callback to get the value of an event-thread only property.
- *
- * @param[in] object The object whose property value is required.
- * @param[in] propertyName The name of the property required.
- * @return The current value of the property for the object specified.
- * @see PropertyRegistration.
- */
- typedef Property::Value* (*GetPropertyFunction)( BaseObject* object, const char* const propertyName );
-}
+/**
+ * @brief Callback to set an event-thread only property.
+ *
+ * @param[in] object The object whose property should be set.
+ * @param[in] propertyName The name of the property required.
+ * @param[in] value The new value of the property for the object specified.
+ * @see PropertyRegistration.
+ */
+using SetPropertyFunction = void (*)(BaseObject*, const char* const, Property::Value*);
+/**
+ * @brief Callback to get the value of an event-thread only property.
+ *
+ * @param[in] object The object whose property value is required.
+ * @param[in] propertyName The name of the property required.
+ * @return The current value of the property for the object specified.
+ * @see PropertyRegistration.
+ */
+using GetPropertyFunction = Property::Value* (*)(BaseObject*, const char* const);
+} // namespace CSharpTypeInfo
} // namespace Dali
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace CSharpTypeRegistry
{
-
-bool RegisterType( const std::string& name, const std::type_info& baseType, CSharpTypeInfo::CreateFunction f )
+bool RegisterType(const std::string& name, const std::type_info& baseType, CSharpTypeInfo::CreateFunction f)
{
- Internal::TypeRegistry *impl = Internal::TypeRegistry::Get();
+ Internal::TypeRegistry* impl = Internal::TypeRegistry::Get();
- impl->Register( name, baseType, f );
+ impl->Register(name, baseType, f);
return true;
}
-bool RegisterProperty( const std::string& objectName,
- const std::string& name,
- Property::Index index,
- Property::Type type,
- CSharpTypeInfo::SetPropertyFunction setFunc,
- CSharpTypeInfo::GetPropertyFunction getFunc )
+bool RegisterProperty(const std::string& objectName,
+ const std::string& name,
+ Property::Index index,
+ Property::Type type,
+ CSharpTypeInfo::SetPropertyFunction setFunc,
+ CSharpTypeInfo::GetPropertyFunction getFunc)
{
+ Internal::TypeRegistry* impl = Internal::TypeRegistry::Get();
- Internal::TypeRegistry *impl = Internal::TypeRegistry::Get();
-
- return impl->RegisterProperty( objectName, name, index, type, setFunc, getFunc );
+ return impl->RegisterProperty(objectName, name, index, type, setFunc, getFunc);
}
-}
+} // namespace CSharpTypeRegistry
} // namespace Dali
#define DALI_CSHARP_TYPE_REGISTRY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
// EXTERNAL INCLUDES
#include <typeinfo>
-
// INTERNAL INCLUDES
-#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/object/csharp-type-info.h>
+#include <dali/public-api/object/type-registry.h>
namespace Dali
{
-
-
/**
* Custom static functions for registering C# custom controls and properties
*
*/
namespace CSharpTypeRegistry
{
-
/**
* @brief Constructor registers the type creation function for a named class or type.
*
* @param [in] f registerType instance creation function
* @return true if the name could be registered.
*/
- DALI_CORE_API bool RegisterType( const std::string& name,
- const std::type_info& baseType,
- CSharpTypeInfo::CreateFunction f );
+DALI_CORE_API bool RegisterType(const std::string& name,
+ const std::type_info& baseType,
+ CSharpTypeInfo::CreateFunction f);
- /**
+/**
* Register an event-thread only property with a type (used by C# Custom controls)
* @param [in] objectName name of the object used to register the type
* @param [in] name Property name
* @param [in] getFunc The function to get the value of a property.
* @return true if the property could be registered.
*/
- DALI_CORE_API bool RegisterProperty( const std::string& objectName,
- const std::string& name,
- Property::Index index,
- Property::Type type,
- CSharpTypeInfo::SetPropertyFunction setFunc,
- CSharpTypeInfo::GetPropertyFunction getFunc );
-}
+DALI_CORE_API bool RegisterProperty(const std::string& objectName,
+ const std::string& name,
+ Property::Index index,
+ Property::Type type,
+ CSharpTypeInfo::SetPropertyFunction setFunc,
+ CSharpTypeInfo::GetPropertyFunction getFunc);
+} // namespace CSharpTypeRegistry
} // namespace Dali
#include <dali/devel-api/object/handle-devel.h>
// INTERNAL INCLUDES
-#include <dali/public-api/object/property-key.h>
#include <dali/internal/event/common/object-impl.h>
#include <dali/internal/event/common/type-info-impl.h>
+#include <dali/public-api/object/property-key.h>
namespace Dali
{
-
namespace DevelHandle
{
-
-void SetTypeInfo( Handle& handle, const TypeInfo& typeInfo )
+void SetTypeInfo(Handle& handle, const TypeInfo& typeInfo)
{
- GetImplementation( handle ).SetTypeInfo( &GetImplementation( typeInfo ) );
+ GetImplementation(handle).SetTypeInfo(&GetImplementation(typeInfo));
}
} // namespace DevelHandle
namespace Dali
{
-
namespace DevelHandle
{
-
/**
* @brief Set the type-info that the object is created by.
*
* @param[in] handle The handle created by this TypeInfo.
* @param[in] typeInfo The TypeInfo that creates the handle.
*/
-DALI_CORE_API void SetTypeInfo( Handle& handle, const TypeInfo& typeInfo );
+DALI_CORE_API void SetTypeInfo(Handle& handle, const TypeInfo& typeInfo);
} // namespace DevelHandle
* These internal macros exist as to perform the compile-time check on the enumeration order, the __COUNTER__ macro is used twice.
* Using it twice within the same macro would result in two different values.
*/
-#define DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, develNamespace, text, valueType, enumIndex ) \
- Dali::PropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace:: develNamespace ::Property::enumIndex, Dali::Property::valueType, &objectType::SetProperty, &objectType::GetProperty ); \
- static_assert( ( objectNamespace:: develNamespace ::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX ) == count );
+#define DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, develNamespace, text, valueType, enumIndex) \
+ Dali::PropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::develNamespace ::Property::enumIndex, Dali::Property::valueType, &objectType::SetProperty, &objectType::GetProperty); \
+ static_assert((objectNamespace::develNamespace ::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX) == count);
-#define DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY( count, typeRegistrationObject, objectNamespace, objectType, develNamespace, text, valueType, enumIndex ) \
- Dali::PropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace:: develNamespace ::Property::enumIndex, Dali::Property::valueType, NULL, &objectType::GetProperty ); \
- static_assert( ( objectNamespace:: develNamespace ::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX ) == count );
+#define DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY(count, typeRegistrationObject, objectNamespace, objectType, develNamespace, text, valueType, enumIndex) \
+ Dali::PropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::develNamespace ::Property::enumIndex, Dali::Property::valueType, NULL, &objectType::GetProperty); \
+ static_assert((objectNamespace::develNamespace ::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX) == count);
/**
* @brief These macros are used to define properties for implementations of CustomActor.
* Using these macros have certain prerequisites on how the property enumeration is defined.
* Please see the Programming Guide (within the generated Doxygen) for full details.
*/
-#define DALI_DEVEL_PROPERTY_REGISTRATION( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, DALI_TOKEN_PASTE( Devel, objectType ), text, valueType, enumIndex )
+#define DALI_DEVEL_PROPERTY_REGISTRATION(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, DALI_TOKEN_PASTE(Devel, objectType), text, valueType, enumIndex)
/**
* @copydoc DALI_DEVEL_PROPERTY_REGISTRATION
*
* @note For Read Only properties
*/
-#define DALI_DEVEL_PROPERTY_REGISTRATION_READ_ONLY( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY( __COUNTER__, typeRegistration, objectNamespace, objectType, DALI_TOKEN_PASTE( Devel, objectType ), text, valueType, enumIndex )
+#define DALI_DEVEL_PROPERTY_REGISTRATION_READ_ONLY(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_DEVEL_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY(__COUNTER__, typeRegistration, objectNamespace, objectType, DALI_TOKEN_PASTE(Devel, objectType), text, valueType, enumIndex)
/**
* @copydoc DALI_DEVEL_PROPERTY_REGISTRATION
*
* @note Animatable property registration
*/
-#define DALI_DEVEL_ANIMATABLE_PROPERTY_REGISTRATION( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_ANIMATABLE_PROPERTY_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, DALI_TOKEN_PASTE( Devel, objectType ), text, valueType, enumIndex )
+#define DALI_DEVEL_ANIMATABLE_PROPERTY_REGISTRATION(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_ANIMATABLE_PROPERTY_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, DALI_TOKEN_PASTE(Devel, objectType), text, valueType, enumIndex)
/**
* @copydoc DALI_DEVEL_PROPERTY_REGISTRATION
* @note Animatable property registration with default value
*
*/
-#define DALI_DEVEL_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT( objectNamespace, objectType, text, value, enumIndex ) \
- DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, DALI_TOKEN_PASTE( Devel, objectType ) , text, value, enumIndex )
+#define DALI_DEVEL_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(objectNamespace, objectType, text, value, enumIndex) \
+ DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, DALI_TOKEN_PASTE(Devel, objectType), text, value, enumIndex)
/**
* @copydoc DALI_DEVEL_PROPERTY_REGISTRATION
* @note Component registration for a Devel Animatable property
*
*/
-#define DALI_DEVEL_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex ) \
- DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, DALI_TOKEN_PASTE( Devel, objectType ), text, enumIndex, baseEnumIndex, componentIndex )
+#define DALI_DEVEL_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION(objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex) \
+ DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, DALI_TOKEN_PASTE(Devel, objectType), text, enumIndex, baseEnumIndex, componentIndex)
#endif // DALI_PROPERTY_HELPER_DEVEL_H
namespace Dali
{
-
namespace DevelFrameBuffer
{
-
-void AttachDepthTexture( FrameBuffer frameBuffer, Texture& texture )
+void AttachDepthTexture(FrameBuffer frameBuffer, Texture& texture)
{
- AttachDepthTexture( frameBuffer, texture, 0u );
+ AttachDepthTexture(frameBuffer, texture, 0u);
}
-void AttachDepthTexture( FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel )
+void AttachDepthTexture(FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel)
{
- if( texture )
+ if(texture)
{
- Internal::TexturePtr texturePtr( &GetImplementation( texture ) );
- GetImplementation( frameBuffer ).AttachDepthTexture( texturePtr, mipmapLevel );
+ Internal::TexturePtr texturePtr(&GetImplementation(texture));
+ GetImplementation(frameBuffer).AttachDepthTexture(texturePtr, mipmapLevel);
}
}
-void AttachDepthStencilTexture( FrameBuffer frameBuffer, Texture& texture )
+void AttachDepthStencilTexture(FrameBuffer frameBuffer, Texture& texture)
{
- AttachDepthStencilTexture( frameBuffer, texture, 0u );
+ AttachDepthStencilTexture(frameBuffer, texture, 0u);
}
-void AttachDepthStencilTexture( FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel )
+void AttachDepthStencilTexture(FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel)
{
- if( texture )
+ if(texture)
{
- Internal::TexturePtr texturePtr( &GetImplementation( texture ) );
- GetImplementation( frameBuffer ).AttachDepthStencilTexture( texturePtr, mipmapLevel );
+ Internal::TexturePtr texturePtr(&GetImplementation(texture));
+ GetImplementation(frameBuffer).AttachDepthStencilTexture(texturePtr, mipmapLevel);
}
}
-Texture GetColorTexture( const FrameBuffer frameBuffer, uint8_t index )
+Texture GetColorTexture(const FrameBuffer frameBuffer, uint8_t index)
{
- Internal::Texture* texturePtr = GetImplementation( frameBuffer ).GetColorTexture(index);
- return Dali::Texture( texturePtr );
+ Internal::Texture* texturePtr = GetImplementation(frameBuffer).GetColorTexture(index);
+ return Dali::Texture(texturePtr);
}
-Texture GetDepthTexture( FrameBuffer frameBuffer )
+Texture GetDepthTexture(FrameBuffer frameBuffer)
{
Internal::Texture* texturePtr = GetImplementation(frameBuffer).GetDepthTexture();
- return Dali::Texture( texturePtr );
+ return Dali::Texture(texturePtr);
}
-Texture GetDepthStencilTexture( FrameBuffer frameBuffer )
+Texture GetDepthStencilTexture(FrameBuffer frameBuffer)
{
Internal::Texture* texturePtr = GetImplementation(frameBuffer).GetDepthStencilTexture();
- return Dali::Texture( texturePtr );
+ return Dali::Texture(texturePtr);
}
} // namespace DevelFrameBuffer
namespace Dali
{
-
namespace DevelFrameBuffer
{
-
/**
* @brief Maximum number of color attachments supported.
*/
* @note The size of the texture has to be same as that of the frame buffer.
* Otherwise, it won't be attached.
*/
-DALI_CORE_API void AttachDepthTexture( FrameBuffer frameBuffer, Texture& texture );
+DALI_CORE_API void AttachDepthTexture(FrameBuffer frameBuffer, Texture& texture);
/**
* @brief Attaches a depth texture to the frame buffer.
* @note The size of the mipmapped texture has to be same as that of the frame buffer.
* Otherwise, it won't be attached.
*/
-DALI_CORE_API void AttachDepthTexture( FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel );
+DALI_CORE_API void AttachDepthTexture(FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel);
/**
* @brief Attaches the base LOD of a stencil texture to the frame buffer.
* @note The size of the texture has to be same as that of the frame buffer.
* Otherwise, it won't be attached.
*/
-DALI_CORE_API void AttachDepthStencilTexture( FrameBuffer frameBuffer, Texture& texture );
+DALI_CORE_API void AttachDepthStencilTexture(FrameBuffer frameBuffer, Texture& texture);
/**
* @brief Attaches a depth/stencil texture to the frame buffer.
* @note The size of the mipmapped texture has to be same as that of the frame buffer.
* Otherwise, it won't be attached.
*/
-DALI_CORE_API void AttachDepthStencilTexture( FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel );
+DALI_CORE_API void AttachDepthStencilTexture(FrameBuffer frameBuffer, Texture& texture, uint32_t mipmapLevel);
/**
* @brief Gets the color texture at the given @a index used as output in the frame buffer.
* @note A maximum of 8 color attachments are supported. Passing an invalid index will return
* an uninitialized handle.
*/
-DALI_CORE_API Texture GetColorTexture( const FrameBuffer frameBuffer, uint8_t index );
+DALI_CORE_API Texture GetColorTexture(const FrameBuffer frameBuffer, uint8_t index);
/**
* @brief Gets the depth texture used as output in the frame buffer.
*
* @return A handle of the texture used as depth output, or an uninitialized handle
*/
-DALI_CORE_API Texture GetDepthTexture( FrameBuffer frameBuffer );
+DALI_CORE_API Texture GetDepthTexture(FrameBuffer frameBuffer);
/**
* @brief Gets the depth/stencil texture used as output in the frame buffer.
*
* @return A handle of the texture used as depth/stencil output, or an uninitialized handle
*/
-DALI_CORE_API Texture GetDepthStencilTexture( FrameBuffer frameBuffer );
+DALI_CORE_API Texture GetDepthStencilTexture(FrameBuffer frameBuffer);
} // namespace DevelFrameBuffer
namespace Dali
{
-
namespace DevelRenderer
{
-
-void AddDrawCommand( Dali::Renderer renderer, const DrawCommand& drawCommand )
+void AddDrawCommand(Dali::Renderer renderer, const DrawCommand& drawCommand)
{
- auto& impl = GetImplementation( renderer );
- impl.AddDrawCommand( drawCommand );
+ auto& impl = GetImplementation(renderer);
+ impl.AddDrawCommand(drawCommand);
}
-} // DevelRenderer
-} // Dali
\ No newline at end of file
+} // namespace DevelRenderer
+} // namespace Dali
\ No newline at end of file
#define DALI_RENDERER_DEVEL_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace DevelRenderer
{
-
/**
* The index of render queue used by the DrawCommand
*/
using RenderQueueIndex = uint32_t;
-constexpr RenderQueueIndex RENDER_QUEUE_OPAQUE = 0; ///< Queue for opaque elements
+constexpr RenderQueueIndex RENDER_QUEUE_OPAQUE = 0; ///< Queue for opaque elements
constexpr RenderQueueIndex RENDER_QUEUE_TRANSPARENT = 1; ///<Queue for transparent elements
-constexpr RenderQueueIndex RENDER_QUEUE_MAX = 2;
+constexpr RenderQueueIndex RENDER_QUEUE_MAX = 2;
/**
* Enum describing way of rendering the primitives (indexed draw, array draw)
*/
struct DrawCommand
{
- DrawType drawType; ///< Type of drawing (indexed, array)
- uint32_t firstIndex ; ///< First index into the geometry array
+ DrawType drawType; ///< Type of drawing (indexed, array)
+ uint32_t firstIndex; ///< First index into the geometry array
uint32_t elementCount; ///< Number of elements to draw
- RenderQueueIndex queue; ///< Queue index
+ RenderQueueIndex queue; ///< Queue index
};
/**
* @param[in] renderer a valid Renderer object
* @param[in] drawCommand Valid DrawCommand to add to the Renderer
*/
-DALI_CORE_API void AddDrawCommand( Dali::Renderer renderer, const DrawCommand& drawCommand );
+DALI_CORE_API void AddDrawCommand(Dali::Renderer renderer, const DrawCommand& drawCommand);
namespace Property
{
-
- enum Type
- {
- DEPTH_INDEX = Dali::Renderer::Property::DEPTH_INDEX,
- FACE_CULLING_MODE = Dali::Renderer::Property::FACE_CULLING_MODE,
- BLEND_MODE = Dali::Renderer::Property::BLEND_MODE,
- BLEND_EQUATION_RGB = Dali::Renderer::Property::BLEND_EQUATION_RGB,
- BLEND_EQUATION_ALPHA = Dali::Renderer::Property::BLEND_EQUATION_ALPHA,
- BLEND_FACTOR_SRC_RGB = Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB,
- BLEND_FACTOR_DEST_RGB = Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB,
- BLEND_FACTOR_SRC_ALPHA = Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA,
- BLEND_FACTOR_DEST_ALPHA = Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA,
- BLEND_COLOR = Dali::Renderer::Property::BLEND_COLOR,
- BLEND_PRE_MULTIPLIED_ALPHA = Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA,
- INDEX_RANGE_FIRST = Dali::Renderer::Property::INDEX_RANGE_FIRST,
- INDEX_RANGE_COUNT = Dali::Renderer::Property::INDEX_RANGE_COUNT,
- DEPTH_WRITE_MODE = Dali::Renderer::Property::DEPTH_WRITE_MODE,
- DEPTH_FUNCTION = Dali::Renderer::Property::DEPTH_FUNCTION,
- DEPTH_TEST_MODE = Dali::Renderer::Property::DEPTH_TEST_MODE,
- RENDER_MODE = Dali::Renderer::Property::RENDER_MODE,
- STENCIL_FUNCTION = Dali::Renderer::Property::STENCIL_FUNCTION,
- STENCIL_FUNCTION_MASK = Dali::Renderer::Property::STENCIL_FUNCTION_MASK,
- STENCIL_FUNCTION_REFERENCE = Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE,
- STENCIL_MASK = Dali::Renderer::Property::STENCIL_MASK,
- STENCIL_OPERATION_ON_FAIL = Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL,
- STENCIL_OPERATION_ON_Z_FAIL = Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL,
- STENCIL_OPERATION_ON_Z_PASS = Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS,
-
- /**
+enum Type
+{
+ DEPTH_INDEX = Dali::Renderer::Property::DEPTH_INDEX,
+ FACE_CULLING_MODE = Dali::Renderer::Property::FACE_CULLING_MODE,
+ BLEND_MODE = Dali::Renderer::Property::BLEND_MODE,
+ BLEND_EQUATION_RGB = Dali::Renderer::Property::BLEND_EQUATION_RGB,
+ BLEND_EQUATION_ALPHA = Dali::Renderer::Property::BLEND_EQUATION_ALPHA,
+ BLEND_FACTOR_SRC_RGB = Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB,
+ BLEND_FACTOR_DEST_RGB = Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB,
+ BLEND_FACTOR_SRC_ALPHA = Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA,
+ BLEND_FACTOR_DEST_ALPHA = Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA,
+ BLEND_COLOR = Dali::Renderer::Property::BLEND_COLOR,
+ BLEND_PRE_MULTIPLIED_ALPHA = Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA,
+ INDEX_RANGE_FIRST = Dali::Renderer::Property::INDEX_RANGE_FIRST,
+ INDEX_RANGE_COUNT = Dali::Renderer::Property::INDEX_RANGE_COUNT,
+ DEPTH_WRITE_MODE = Dali::Renderer::Property::DEPTH_WRITE_MODE,
+ DEPTH_FUNCTION = Dali::Renderer::Property::DEPTH_FUNCTION,
+ DEPTH_TEST_MODE = Dali::Renderer::Property::DEPTH_TEST_MODE,
+ RENDER_MODE = Dali::Renderer::Property::RENDER_MODE,
+ STENCIL_FUNCTION = Dali::Renderer::Property::STENCIL_FUNCTION,
+ STENCIL_FUNCTION_MASK = Dali::Renderer::Property::STENCIL_FUNCTION_MASK,
+ STENCIL_FUNCTION_REFERENCE = Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE,
+ STENCIL_MASK = Dali::Renderer::Property::STENCIL_MASK,
+ STENCIL_OPERATION_ON_FAIL = Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL,
+ STENCIL_OPERATION_ON_Z_FAIL = Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL,
+ STENCIL_OPERATION_ON_Z_PASS = Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS,
+
+ /**
* @brief The opacity of the renderer.
* @details Name "opacity", type Property::FLOAT.
*/
- OPACITY = STENCIL_OPERATION_ON_Z_PASS + 1,
+ OPACITY = STENCIL_OPERATION_ON_Z_PASS + 1,
- /**
+ /**
* @brief The rendering behavior of the renderer.
* @details Name "renderingBehavior", type Property::INTEGER.
*/
- RENDERING_BEHAVIOR = STENCIL_OPERATION_ON_Z_PASS + 2,
- };
+ RENDERING_BEHAVIOR = STENCIL_OPERATION_ON_Z_PASS + 2,
+};
} // namespace Property
namespace Rendering
{
-
-
-
/**
* @brief Enumeration for the rendering behavior
*/
enum Type
{
- IF_REQUIRED, ///< Default. Will only render if required to do so.
- CONTINUOUSLY ///< Will render continuously.
+ IF_REQUIRED, ///< Default. Will only render if required to do so.
+ CONTINUOUSLY ///< Will render continuously.
};
} // namespace Rendering
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <dali/devel-api/rendering/texture-devel.h>
+#include <dali/internal/event/rendering/texture-impl.h>
+
+namespace Dali
+{
+namespace DevelTexture
+{
+bool IsNative(Dali::Texture texture)
+{
+ auto& impl = GetImplementation(texture);
+ return impl.IsNative();
+}
+
+bool ApplyNativeFragmentShader(Dali::Texture texture, std::string& shader)
+{
+ auto& impl = GetImplementation(texture);
+ return impl.ApplyNativeFragmentShader(shader);
+}
+
+} // namespace DevelTexture
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TEXTURE_DEVEL_H
+#define DALI_TEXTURE_DEVEL_H
+
+/*
+ * Copyright (c) 2020 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/public-api/rendering/texture.h>
+
+namespace Dali
+{
+namespace DevelTexture
+{
+/**
+ * @brief Function to determine if a texture is backed by a native image.
+ *
+ * @return True if the texture is a native image.
+ */
+bool DALI_CORE_API IsNative(Dali::Texture texture);
+
+/**
+ * @brief Converts shader for native image.
+ *
+ * Applies any specific native shader prefix and sampler code to the
+ * given shader.
+ *
+ * @param[in] texture The texture the shader will apply to
+ * @param[in] shader The fragment shader code to modify
+ * @return True if the shader code was modified
+ */
+bool DALI_CORE_API ApplyNativeFragmentShader(Dali::Texture texture, std::string& shader);
+
+} // namespace DevelTexture
+} // namespace Dali
+
+#endif // DALI_TEXTURE_DEVEL_H
#define DALI_ENUM_HELPER_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* Macros for creating value, typically enumerations, to string tables.
* Example:
* By default, Dali::Scripting::StringEnum is used as the type for the table, however, a different type can be specified by using
* DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE.
*/
-#define DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( type, t ) const type t##_TABLE[] = {
-#define DALI_ENUM_TO_STRING_TABLE_BEGIN( t ) DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( Dali::Scripting::StringEnum, t )
-#define DALI_ENUM_TO_STRING_TABLE_END( t ) }; const uint32_t t##_TABLE_COUNT = static_cast<uint32_t>( sizeof( t##_TABLE ) / sizeof( t##_TABLE[0] ) );
-#define DALI_ENUM_TO_STRING( s ) { #s, s },
+#define DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE(type, t) const type t##_TABLE[] = {
+#define DALI_ENUM_TO_STRING_TABLE_BEGIN(t) DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE(Dali::Scripting::StringEnum, t)
+#define DALI_ENUM_TO_STRING_TABLE_END(t) \
+ } \
+ ; \
+ const uint32_t t##_TABLE_COUNT = static_cast<uint32_t>(sizeof(t##_TABLE) / sizeof(t##_TABLE[0]));
+#define DALI_ENUM_TO_STRING(s) {#s, s},
/**
* Adds a value, typically an enum, to the table within a scope but without the scope name
* Example converts ( Layer, LAYER_UI ) to ( "LAYER_UI", Layer::LayerUI )
*/
-#define DALI_ENUM_TO_STRING_WITH_SCOPE( className, enumName ) { #enumName, className::enumName },
+#define DALI_ENUM_TO_STRING_WITH_SCOPE(className, enumName) {#enumName, className::enumName},
} // namespace Dali
#include <dali/devel-api/scripting/scripting.h>
// INTERNAL INCLUDES
+#include <dali/internal/event/common/property-helper.h>
#include <dali/public-api/actors/actor.h>
-#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/property-array.h>
-#include <dali/internal/event/common/property-helper.h>
+#include <dali/public-api/object/type-registry.h>
namespace Dali
{
-
namespace Scripting
{
-
-bool EnumStringToInteger( const char * const value, const StringEnum* const enumTable, uint32_t tableCount, int& integerEnum )
+bool EnumStringToInteger(const char* const value, const StringEnum* const enumTable, uint32_t tableCount, int& integerEnum)
{
int ret = 0;
bool found = false;
- bool done = false;
+ bool done = false;
- if( value && enumTable && tableCount )
+ if(value && enumTable && tableCount)
{
const char* pValue = value;
const StringEnum* table = enumTable;
- for ( uint32_t i = 0; i < tableCount; ++i )
+ for(uint32_t i = 0; i < tableCount; ++i)
{
- if( Internal::CompareTokens( pValue, table->string, size ) )
+ if(Internal::CompareTokens(pValue, table->string, size))
{
found = true;
ret |= table->value;
if(found)
{
// allow comma separated or'd value
- if( *(pValue+size) == ',' )
+ if(*(pValue + size) == ',')
{
pValue += size + 1;
done = false;
}
}
-
}
integerEnum = ret;
}
- if ( !found )
+ if(!found)
{
- DALI_LOG_ERROR( "Unknown enumeration string %s\n", value );
+ DALI_LOG_ERROR("Unknown enumeration string %s\n", value);
}
return found;
}
-uint32_t FindEnumIndex( const char* value, const StringEnum* table, uint32_t tableCount )
+uint32_t FindEnumIndex(const char* value, const StringEnum* table, uint32_t tableCount)
{
uint32_t index = 0;
- bool found = false;
- for ( uint32_t i = 0; i < tableCount; ++i, ++index )
+ bool found = false;
+ for(uint32_t i = 0; i < tableCount; ++i, ++index)
{
uint32_t sizeIgnored = 0;
- if( Internal::CompareTokens( value, table->string, sizeIgnored ) )
+ if(Internal::CompareTokens(value, table->string, sizeIgnored))
{
found = true;
break;
}
++table;
}
- if ( !found )
+ if(!found)
{
- DALI_LOG_ERROR( "Unknown enumeration string %s\n", value );
+ DALI_LOG_ERROR("Unknown enumeration string %s\n", value);
}
return index;
}
-Actor NewActor( const Property::Map& map )
+Actor NewActor(const Property::Map& map)
{
BaseHandle handle;
// First find type and create Actor
- Property::Value* typeValue = map.Find( "type" );
- if ( typeValue )
+ Property::Value* typeValue = map.Find("type");
+ if(typeValue)
{
- TypeInfo type = TypeRegistry::Get().GetTypeInfo( typeValue->Get< std::string >() );
- if ( type )
+ TypeInfo type = TypeRegistry::Get().GetTypeInfo(typeValue->Get<std::string>());
+ if(type)
{
handle = type.CreateInstance();
}
}
- if ( !handle )
+ if(!handle)
{
- DALI_LOG_ERROR( "Actor type not provided\n" );
+ DALI_LOG_ERROR("Actor type not provided\n");
return Actor();
}
- Actor actor( Actor::DownCast( handle ) );
+ Actor actor(Actor::DownCast(handle));
- if ( actor )
+ if(actor)
{
// Now set the properties, or create children
- for ( Property::Map::SizeType i = 0, mapCount = map.Count(); i < mapCount; ++i )
+ for(Property::Map::SizeType i = 0, mapCount = map.Count(); i < mapCount; ++i)
{
- const KeyValuePair pair( map.GetKeyValue( i ) );
- if( pair.first.type == Property::Key::INDEX )
+ const KeyValuePair pair(map.GetKeyValue(i));
+ if(pair.first.type == Property::Key::INDEX)
{
continue;
}
- const std::string& key( pair.first.stringKey );
- if ( key == "type" )
+ const std::string& key(pair.first.stringKey);
+ if(key == "type")
{
continue;
}
- const Property::Value& value( pair.second );
+ const Property::Value& value(pair.second);
- if ( key == "actors" )
+ if(key == "actors")
{
// Create children
- Property::Array actorArray = value.Get< Property::Array >();
- for ( Property::Array::SizeType i = 0; i < actorArray.Size(); ++i)
+ Property::Array actorArray = value.Get<Property::Array>();
+ for(Property::Array::SizeType i = 0; i < actorArray.Size(); ++i)
{
- actor.Add( NewActor( actorArray[i].Get< Property::Map >() ) );
+ actor.Add(NewActor(actorArray[i].Get<Property::Map>()));
}
}
else
{
- Property::Index index( actor.GetPropertyIndex( key ) );
+ Property::Index index(actor.GetPropertyIndex(key));
- if ( index != Property::INVALID_INDEX )
+ if(index != Property::INVALID_INDEX)
{
- actor.SetProperty( index, value );
+ actor.SetProperty(index, value);
}
}
}
return actor;
}
-void CreatePropertyMap( Actor actor, Property::Map& map )
+void CreatePropertyMap(Actor actor, Property::Map& map)
{
map.Clear();
- if ( actor )
+ if(actor)
{
- map[ "type" ] = actor.GetTypeName();
+ map["type"] = actor.GetTypeName();
// Default properties
Property::IndexContainer indices;
- actor.GetPropertyIndices( indices );
+ actor.GetPropertyIndices(indices);
const Property::IndexContainer::ConstIterator endIter = indices.End();
- for ( Property::IndexContainer::Iterator iter = indices.Begin(); iter != endIter; ++iter )
+ for(Property::IndexContainer::Iterator iter = indices.Begin(); iter != endIter; ++iter)
{
- map[ actor.GetPropertyName( *iter ) ] = actor.GetProperty( *iter );
+ map[actor.GetPropertyName(*iter)] = actor.GetProperty(*iter);
}
// Children
- std::size_t childCount( actor.GetChildCount() );
- if ( childCount )
+ std::size_t childCount(actor.GetChildCount());
+ if(childCount)
{
Property::Array childArray;
- for ( uint32_t child = 0; child < childCount; ++child )
+ for(uint32_t child = 0; child < childCount; ++child)
{
Property::Map childMap;
- CreatePropertyMap( actor.GetChildAt( child ), childMap );
- childArray.PushBack( childMap );
+ CreatePropertyMap(actor.GetChildAt(child), childMap);
+ childArray.PushBack(childMap);
}
- map[ "actors" ] = childArray;
+ map["actors"] = childArray;
}
}
}
-void NewAnimation( const Property::Map& map, Dali::AnimationData& outputAnimationData )
+void NewAnimation(const Property::Map& map, Dali::AnimationData& outputAnimationData)
{
// Note: Builder cannot currently pass generic Property::Maps "{" that are nested, so currently we can only have one AnimateTo per animation.
Dali::AnimationData::AnimationDataElement* element = new Dali::AnimationData::AnimationDataElement();
- element->alphaFunction = AlphaFunction::LINEAR;
- element->timePeriodDelay = 0.0f;
+
+ element->alphaFunction = AlphaFunction::LINEAR;
+ element->timePeriodDelay = 0.0f;
element->timePeriodDuration = 1.0f;
// Now set the properties, or create children
- for( Property::Map::SizeType i = 0, animationMapCount = map.Count(); i < animationMapCount; ++i )
+ for(Property::Map::SizeType i = 0, animationMapCount = map.Count(); i < animationMapCount; ++i)
{
- const KeyValuePair pair( map.GetKeyValue( i ) );
- if( pair.first.type == Property::Key::INDEX )
+ const KeyValuePair pair(map.GetKeyValue(i));
+ if(pair.first.type == Property::Key::INDEX)
{
continue; // We don't consider index keys.
}
- const std::string& key( pair.first.stringKey );
+ const std::string& key(pair.first.stringKey);
- const Property::Value& value( pair.second );
+ const Property::Value& value(pair.second);
- if( key == "actor" )
+ if(key == "actor")
{
- element->actor = value.Get< std::string >();
+ element->actor = value.Get<std::string>();
}
- else if( key == "property" )
+ else if(key == "property")
{
- element->property = value.Get< std::string >();
+ element->property = value.Get<std::string>();
}
- else if( key == "value" )
+ else if(key == "value")
{
element->value = value;
}
- else if( key == "alphaFunction" )
+ else if(key == "alphaFunction")
{
- std::string alphaFunctionValue = value.Get< std::string >();
+ std::string alphaFunctionValue = value.Get<std::string>();
- if( alphaFunctionValue == "LINEAR" )
+ if(alphaFunctionValue == "LINEAR")
{
element->alphaFunction = AlphaFunction::LINEAR;
}
- else if( alphaFunctionValue == "REVERSE" )
+ else if(alphaFunctionValue == "REVERSE")
{
element->alphaFunction = AlphaFunction::REVERSE;
}
- else if( alphaFunctionValue == "EASE_IN_SQUARE" )
+ else if(alphaFunctionValue == "EASE_IN_SQUARE")
{
element->alphaFunction = AlphaFunction::EASE_IN_SQUARE;
}
- else if( alphaFunctionValue == "EASE_OUT_SQUARE" )
+ else if(alphaFunctionValue == "EASE_OUT_SQUARE")
{
element->alphaFunction = AlphaFunction::EASE_OUT_SQUARE;
}
- else if( alphaFunctionValue == "EASE_IN" )
+ else if(alphaFunctionValue == "EASE_IN")
{
element->alphaFunction = AlphaFunction::EASE_IN;
}
- else if( alphaFunctionValue == "EASE_OUT" )
+ else if(alphaFunctionValue == "EASE_OUT")
{
element->alphaFunction = AlphaFunction::EASE_OUT;
}
- else if( alphaFunctionValue == "EASE_IN_OUT" )
+ else if(alphaFunctionValue == "EASE_IN_OUT")
{
element->alphaFunction = AlphaFunction::EASE_IN_OUT;
}
- else if( alphaFunctionValue == "EASE_IN_SINE" )
+ else if(alphaFunctionValue == "EASE_IN_SINE")
{
element->alphaFunction = AlphaFunction::EASE_IN_SINE;
}
- else if( alphaFunctionValue == "EASE_OUT_SINE" )
+ else if(alphaFunctionValue == "EASE_OUT_SINE")
{
element->alphaFunction = AlphaFunction::EASE_OUT_SINE;
}
- else if( alphaFunctionValue == "EASE_IN_OUT_SINE" )
+ else if(alphaFunctionValue == "EASE_IN_OUT_SINE")
{
element->alphaFunction = AlphaFunction::EASE_IN_OUT_SINE;
}
- else if( alphaFunctionValue == "BOUNCE" )
+ else if(alphaFunctionValue == "BOUNCE")
{
element->alphaFunction = AlphaFunction::BOUNCE;
}
- else if( alphaFunctionValue == "SIN" )
+ else if(alphaFunctionValue == "SIN")
{
element->alphaFunction = AlphaFunction::SIN;
}
- else if( alphaFunctionValue == "EASE_OUT_BACK" )
+ else if(alphaFunctionValue == "EASE_OUT_BACK")
{
element->alphaFunction = AlphaFunction::EASE_OUT_BACK;
}
}
- else if( key == "timePeriod" )
+ else if(key == "timePeriod")
{
- Property::Map timeMap = value.Get< Property::Map >();
- for( Property::Map::SizeType i = 0; i < timeMap.Count(); ++i )
+ Property::Map timeMap = value.Get<Property::Map>();
+ for(Property::Map::SizeType i = 0; i < timeMap.Count(); ++i)
{
- const KeyValuePair timePair( timeMap.GetKeyValue( i ) );
- if( timePair.first.type == Property::Key::INDEX )
+ const KeyValuePair timePair(timeMap.GetKeyValue(i));
+ if(timePair.first.type == Property::Key::INDEX)
{
continue;
}
- const std::string& key( timePair.first.stringKey );
+ const std::string& key(timePair.first.stringKey);
- if( key == "delay" )
+ if(key == "delay")
{
- element->timePeriodDelay = timePair.second.Get< float >();
+ element->timePeriodDelay = timePair.second.Get<float>();
}
- else if( key == "duration" )
+ else if(key == "duration")
{
- element->timePeriodDuration = timePair.second.Get< float >();
+ element->timePeriodDuration = timePair.second.Get<float>();
}
}
}
}
- outputAnimationData.Add( element );
+ outputAnimationData.Add(element);
}
-} // namespace scripting
+} // namespace Scripting
} // namespace Dali
*/
// INTERNAL INCLUDES
+#include <dali/devel-api/animation/animation-data.h>
#include <dali/public-api/actors/actor-enumerations.h>
#include <dali/public-api/actors/draw-mode.h>
-#include <dali/devel-api/animation/animation-data.h>
#include <dali/public-api/object/property-array.h>
#include <dali/public-api/object/property-map.h>
#include <dali/public-api/object/property-value.h>
namespace Dali
{
-
class Actor;
/**
*/
namespace Scripting
{
-
/**
* @brief Structure which stores an enumeration and its string equivalent.
*/
struct StringEnum
{
- const char* string; ///< The string representation
- const int32_t value; ///< The enumeration value wrapped in int
+ const char* string; ///< The string representation
+ const int32_t value; ///< The enumeration value wrapped in int
};
/**
* @param[in] tableCount Number of items in the array.
* @return The index of the enumeration. If enumeration is not found, logs an error and returns tableCount.
*/
-DALI_CORE_API uint32_t FindEnumIndex( const char* value, const StringEnum* table, uint32_t tableCount );
+DALI_CORE_API uint32_t FindEnumIndex(const char* value, const StringEnum* table, uint32_t tableCount);
/**
* @brief Find the enum as an integer from the table
* @param[out] integerEnum The value of the enum.
* @return true if one or more enums in value.
*/
-DALI_CORE_API bool EnumStringToInteger( const char* const value, const StringEnum* const table, uint32_t tableCount, int& integerEnum );
+DALI_CORE_API bool EnumStringToInteger(const char* const value, const StringEnum* const table, uint32_t tableCount, int& integerEnum);
/**
* @brief Chooses the appropriate enumeration for the provided string from the given table.
*
* @return True if the value was found from the table
*/
-template< typename T >
-bool GetEnumeration( const char* value, const StringEnum* table, uint32_t tableCount, T& result )
+template<typename T>
+bool GetEnumeration(const char* value, const StringEnum* table, uint32_t tableCount, T& result)
{
- bool retVal( false );
- if( table )
+ bool retVal(false);
+ if(table)
{
int integerEnum = 0;
// check to avoid crash, not asserting on purpose, error is logged instead
- if( EnumStringToInteger( value, table, tableCount, integerEnum ) )
+ if(EnumStringToInteger(value, table, tableCount, integerEnum))
{
- result = static_cast<T>( integerEnum );
+ result = static_cast<T>(integerEnum);
retVal = true;
}
}
* @param[out] result The enum value. This is not modified if the enumeration could not be converted.
* @return True if the value was found successfully AND the value has changed. This is to allow the caller to do nothing if there is no change.
*/
-template< typename T >
-bool GetEnumerationProperty( const Property::Value& propertyValue, const StringEnum* table, uint32_t tableCount, T& result )
+template<typename T>
+bool GetEnumerationProperty(const Property::Value& propertyValue, const StringEnum* table, uint32_t tableCount, T& result)
{
- int newValue;
- bool set = false;
+ int newValue;
+ bool set = false;
Property::Type type = propertyValue.GetType();
- if( type == Property::INTEGER )
+ if(type == Property::INTEGER)
{
// Attempt to fetch the property as an INTEGER type.
- if( propertyValue.Get( newValue ) )
+ if(propertyValue.Get(newValue))
{
// Success.
set = true;
}
}
- else if( type == Property::STRING )
+ else if(type == Property::STRING)
{
// Attempt to fetch the property as an STRING type, and convert it from string to enumeration value.
std::string propertyString;
- if( table && propertyValue.Get( propertyString ) && EnumStringToInteger( propertyString.c_str(), table, tableCount, newValue ) )
+ if(table && propertyValue.Get(propertyString) && EnumStringToInteger(propertyString.c_str(), table, tableCount, newValue))
{
// Success.
set = true;
}
// If the property was converted OK, AND the value has changed, update the result and return true.
- if( set && ( result != static_cast<T>( newValue ) ) )
+ if(set && (result != static_cast<T>(newValue)))
{
- result = static_cast<T>( newValue );
+ result = static_cast<T>(newValue);
return true;
}
* @param[out] result The enum value. This is not modified if the enumeration could not be converted.
* @return True if the value was found successfully AND the value has changed. This is to allow the caller to do nothing if there is no change.
*/
-template< typename T >
-bool GetBitmaskEnumerationProperty( const Property::Value& propertyValue, const Scripting::StringEnum* table, uint32_t tableCount, T& result )
+template<typename T>
+bool GetBitmaskEnumerationProperty(const Property::Value& propertyValue, const Scripting::StringEnum* table, uint32_t tableCount, T& result)
{
bool returnValue = true;
// Evaluate as a single INTEGER or STRING first.
- if( !GetEnumerationProperty( propertyValue, table, tableCount, result ) )
+ if(!GetEnumerationProperty(propertyValue, table, tableCount, result))
{
// If not, then check if it's an ARRAY
- if ( propertyValue.GetType() == Property::ARRAY )
+ if(propertyValue.GetType() == Property::ARRAY)
{
- int newValue = 0;
+ int newValue = 0;
Property::Array array;
- propertyValue.Get( array );
- for( Property::Array::SizeType i = 0; i < array.Count(); ++i )
+ propertyValue.Get(array);
+ for(Property::Array::SizeType i = 0; i < array.Count(); ++i)
{
- Property::Value currentValue = array[ i ];
+ Property::Value currentValue = array[i];
// Use an initial value of -1 so any successful property conversion
// causes a change (and true to be returned).
- T current = static_cast< T >( -1 );
- if( GetEnumerationProperty( currentValue, table, tableCount, current ) )
+ T current = static_cast<T>(-1);
+ if(GetEnumerationProperty(currentValue, table, tableCount, current))
{
newValue |= current;
}
}
// If we didn't hit an invalid type and the value has changed, update the result.
- if( returnValue && ( result != static_cast<T>( newValue ) ) )
+ if(returnValue && (result != static_cast<T>(newValue)))
{
- result = static_cast<T>( newValue );
+ result = static_cast<T>(newValue);
}
}
else
*
* @note The caller is NOT responsible for cleaning up the returned pointer as it is statically allocated.
*/
-template< typename T >
-const char* GetEnumerationName( T value, const StringEnum* table, uint32_t tableCount )
+template<typename T>
+const char* GetEnumerationName(T value, const StringEnum* table, uint32_t tableCount)
{
- if( table )
+ if(table)
{
- for ( uint32_t i = 0; i < tableCount; ++i )
+ for(uint32_t i = 0; i < tableCount; ++i)
{
- if ( value == T(table[ i ].value) )
+ if(value == T(table[i].value))
{
- return table[ i ].string;
+ return table[i].string;
}
}
}
- return NULL;
+ return nullptr;
}
/**
*
* @note The caller is NOT responsible for cleaning up the returned pointer as it is statically allocated.
*/
-template< typename T >
-const char * GetLinearEnumerationName( T value, const StringEnum* table, uint32_t tableCount )
+template<typename T>
+const char* GetLinearEnumerationName(T value, const StringEnum* table, uint32_t tableCount)
{
- if ( table && ( value > 0 || value <= static_cast<int>( tableCount ) ) )
+ if(table && (value > 0 || value <= static_cast<int>(tableCount)))
{
return table[value].string;
}
- return NULL;
+ return nullptr;
}
/**
*
* @return A handle to the newly created actor.
*/
-DALI_CORE_API Actor NewActor( const Property::Map& map );
+DALI_CORE_API Actor NewActor(const Property::Map& map);
/**
* @brief Creates a Property::Map from the actor provided.
* @param[in] actor The base-actor from which a Property::Map should be created
* @param[out] map This map is cleared and a property map of actor and its children is filled in
*/
-DALI_CORE_API void CreatePropertyMap( Actor actor, Property::Map& map );
+DALI_CORE_API void CreatePropertyMap(Actor actor, Property::Map& map);
/**
* @brief Creates description data required to create an Animation object from a property map.
* @param[in] map The property value map containing the animation description
* @param[out] outputAnimationData Resultant data retrieved from the property map is written here
*/
-DALI_CORE_API void NewAnimation( const Property::Map& map, Dali::AnimationData& outputAnimationData );
+DALI_CORE_API void NewAnimation(const Property::Map& map, Dali::AnimationData& outputAnimationData);
} // namespace Scripting
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
// CallbackBaseFunctor methods:
-SignalDelegate::CallbackBaseFunctor::CallbackBaseFunctor( CallbackBase* callback )
-: mCallback( callback )
+SignalDelegate::CallbackBaseFunctor::CallbackBaseFunctor(CallbackBase* callback)
+: mCallback(callback)
{
}
void SignalDelegate::CallbackBaseFunctor::operator()()
{
- if( mCallback )
+ if(mCallback)
{
- CallbackBase::Execute( *mCallback );
+ CallbackBase::Execute(*mCallback);
}
}
delete mCallback;
}
-
// SignalDelegate methods:
-SignalDelegate::SignalDelegate( Dali::Actor connectActor, const std::string& signalName )
-: mIsConnected( false ),
- mConnectActor( connectActor ),
- mSignalName( signalName )
+SignalDelegate::SignalDelegate(Dali::Actor connectActor, const std::string& signalName)
+: mIsConnected(false),
+ mConnectActor(connectActor),
+ mSignalName(signalName)
{
}
return mIsConnected;
}
-
} // namespace Dali
#define DALI_SIGNAL_DELEGATE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* @brief The SignalDelegate object allows direct connection to a signal that has been pre-configured internally.
*
class DALI_CORE_API SignalDelegate
{
public:
-
/**
* @brief Create and set up a signal delegate.
*
* @param[in] connectActor The actor whose signal should be connected to.
* @param[in] signalName The name of the signal within the actor to connect to.
*/
- SignalDelegate( Dali::Actor connectActor, const std::string& signalName );
+ SignalDelegate(Dali::Actor connectActor, const std::string& signalName);
/**
* @brief Destructor.
}
public:
-
/**
* @brief Connect to a FunctorDelegate as received from a type-registry signal connection call.
*
* @param[in] functorDelegate A functor delegate object that must be executed when the signal is emitted.
* @return True of the connection was made, false otherwise.
*/
- bool Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* functorDelegate )
+ bool Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* functorDelegate)
{
- if( !mIsConnected )
+ if(!mIsConnected)
{
// Note: We have to new the CallbackBaseFunctor rather than have it as a concrete object, as it
// is converted to a FunctorDelegate again within ConnectSignal. FunctorDelegates gain ownership
// of any functor they are created from and therefore always attempt to delete them.
- CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor( new CallbackFunctorDelegate0( functorDelegate ) );
- mConnectActor.ConnectSignal( connectionTracker, mSignalName, *callbackFunctor );
+ CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor(new CallbackFunctorDelegate0(functorDelegate));
+ mConnectActor.ConnectSignal(connectionTracker, mSignalName, *callbackFunctor);
mIsConnected = true;
return true;
* @param[in] memberFunction The member-function to call when the signal is emitted.
* @return True of the connection was made, false otherwise.
*/
- template< class T >
- bool Connect( T* object, void ( T::*memberFunction )( void ) )
+ template<class T>
+ bool Connect(T* object, void (T::*memberFunction)(void))
{
- if( !mIsConnected )
+ if(!mIsConnected)
{
- CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor( MakeCallback( object, memberFunction ) );
- mConnectActor.ConnectSignal( object, mSignalName, *callbackFunctor );
+ CallbackBaseFunctor* callbackFunctor = new CallbackBaseFunctor(MakeCallback(object, memberFunction));
+ mConnectActor.ConnectSignal(object, mSignalName, *callbackFunctor);
mIsConnected = true;
return true;
*/
bool IsConnected();
-
private:
-
/**
* This functor is used by SignalDelegate in order to callback to a non-static member function
* (after it has been converted to a CallbackBase).
*
* @param[in] callback A CallbackBase which can be created from a member function, or a FunctorDelegate.
*/
- CallbackBaseFunctor( CallbackBase* callback );
+ CallbackBaseFunctor(CallbackBase* callback);
/**
* @brief Executes the functor.
*/
~CallbackBaseFunctor();
- private:
-
- CallbackBase* mCallback; ///< Stores (and owns) the callback to be called on execution.
+ private:
+ CallbackBase* mCallback; ///< Stores (and owns) the callback to be called on execution.
};
private:
-
/**
* @brief Not defined.
*/
- SignalDelegate( const SignalDelegate& rhs );
+ SignalDelegate(const SignalDelegate& rhs);
/**
* @brief Not defined.
*/
- const SignalDelegate& operator=( const SignalDelegate& rhs );
+ const SignalDelegate& operator=(const SignalDelegate& rhs);
private:
- bool mIsConnected; ///< Boolean to know if it is connected already.
+ bool mIsConnected; ///< Boolean to know if it is connected already.
Dali::Actor mConnectActor; ///< The actor owning the signal to connect to.
std::string mSignalName; ///< The name of the signal to connect to.
};
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/devel-api/threading/conditional-wait.h>
// EXTERNAL INCLUDES
-#include <mutex>
#include <condition_variable>
+#include <mutex>
// INTERNAL INCLUDES
#include <dali/integration-api/debug.h>
*/
struct ConditionalWait::ConditionalWaitImpl
{
- std::mutex mutex;
+ std::mutex mutex;
std::condition_variable condition;
- volatile unsigned int count;
+ volatile unsigned int count;
};
/**
*/
struct ConditionalWait::ScopedLock::ScopedLockImpl
{
- ScopedLockImpl( ConditionalWait& wait )
- : wait( wait ),
- lock( wait.mImpl->mutex ) // locks for the lifecycle of this object
- { }
- ConditionalWait& wait;
+ ScopedLockImpl(ConditionalWait& wait)
+ : wait(wait),
+ lock(wait.mImpl->mutex) // locks for the lifecycle of this object
+ {
+ }
+ ConditionalWait& wait;
std::unique_lock<std::mutex> lock;
};
-ConditionalWait::ScopedLock::ScopedLock( ConditionalWait& wait )
-: mImpl( new ConditionalWait::ScopedLock::ScopedLockImpl( wait ) )
+ConditionalWait::ScopedLock::ScopedLock(ConditionalWait& wait)
+: mImpl(new ConditionalWait::ScopedLock::ScopedLockImpl(wait))
{
Internal::MutexTrace::Lock(); // matching sequence in mutex.cpp
}
}
ConditionalWait::ConditionalWait()
-: mImpl( new ConditionalWaitImpl )
+: mImpl(new ConditionalWaitImpl)
{
mImpl->count = 0;
}
void ConditionalWait::Notify()
{
// conditional wait requires a lock to be held
- ScopedLock lock( *this );
+ ScopedLock lock(*this);
volatile unsigned int previousCount = mImpl->count;
+
mImpl->count = 0; // change state before broadcast as that may wake clients immediately
// notify does nothing if the thread is not waiting but still has a system call overhead
// notify all threads to continue
- if( 0 != previousCount )
+ if(0 != previousCount)
{
mImpl->condition.notify_all(); // no return value
}
}
-void ConditionalWait::Notify( const ScopedLock& scope )
+void ConditionalWait::Notify(const ScopedLock& scope)
{
// Scope must be locked:
- DALI_ASSERT_DEBUG( &scope.GetLockedWait() == this );
+ DALI_ASSERT_DEBUG(&scope.GetLockedWait() == this);
volatile unsigned int previousCount = mImpl->count;
+
mImpl->count = 0; // change state before broadcast as that may wake clients immediately
// notify does nothing if the thread is not waiting but still has a system call overhead
// notify all threads to continue
- if( 0 != previousCount )
+ if(0 != previousCount)
{
mImpl->condition.notify_all(); // no return value
}
void ConditionalWait::Wait()
{
// conditional wait requires a lock to be held
- ScopedLock scope( *this );
+ ScopedLock scope(*this);
++(mImpl->count);
// conditional wait may wake up without anyone calling Notify
do
{
// wait while condition changes
- mImpl->condition.wait( scope.mImpl->lock ); // need to pass in the std::unique_lock
- }
- while( 0 != mImpl->count );
+ mImpl->condition.wait(scope.mImpl->lock); // need to pass in the std::unique_lock
+ } while(0 != mImpl->count);
}
-void ConditionalWait::Wait( const ScopedLock& scope )
+void ConditionalWait::Wait(const ScopedLock& scope)
{
// Scope must be locked:
- DALI_ASSERT_DEBUG( &scope.GetLockedWait() == this );
+ DALI_ASSERT_DEBUG(&scope.GetLockedWait() == this);
++(mImpl->count);
do
{
// wait while condition changes
- mImpl->condition.wait( scope.mImpl->lock ); // need to pass in the std::unique_lock
- }
- while( 0 != mImpl->count );
+ mImpl->condition.wait(scope.mImpl->lock); // need to pass in the std::unique_lock
+ } while(0 != mImpl->count);
// We return with our mutex locked safe in the knowledge that the ScopedLock
// passed in will unlock it in the caller.
#define DALI_CONDITIONAL_WAIT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
/**
* Helper class to allow conditional waiting and notifications between multiple threads.
*/
class DALI_CORE_API ConditionalWait
{
public:
-
/**
* @brief Allows client code to synchronize updates to its own state with the
* internal state of a ConditionalWait object.
* @brief Will acquire the internal mutex of the ConditionalWait object passed in.
* @param[in] wait The ConditionalWait object to lock.
*/
- ScopedLock( ConditionalWait& wait );
+ ScopedLock(ConditionalWait& wait);
/**
* Destructor
ConditionalWait& GetLockedWait() const;
public: // Data, public to allow nesting class to access
-
struct ScopedLockImpl;
ScopedLockImpl* mImpl;
private:
-
// Not implemented as ScopedLock cannot be copied:
- ScopedLock( const ScopedLock& );
- const ScopedLock& operator=( const ScopedLock& );
+ ScopedLock(const ScopedLock&);
+ const ScopedLock& operator=(const ScopedLock&);
};
/**
*
* @param[in] scope A pre-existing lock on the internal state of this object.
*/
- void Notify( const ScopedLock& scope );
+ void Notify(const ScopedLock& scope);
/**
* @brief Wait for another thread to notify us when the condition is true and we can continue
* @param[in] scope A pre-existing lock on the internal state of this object.
* @pre scope must have been passed this ConditionalWait during its construction.
*/
- void Wait( const ScopedLock& scope );
+ void Wait(const ScopedLock& scope);
/**
* @brief Return the count of threads waiting for this conditional
unsigned int GetWaitCount() const;
private:
-
// Not implemented as ConditionalWait is not copyable
- ConditionalWait( const ConditionalWait& );
- const ConditionalWait& operator=( const ConditionalWait& );
+ ConditionalWait(const ConditionalWait&);
+ const ConditionalWait& operator=(const ConditionalWait&);
struct ConditionalWaitImpl;
ConditionalWaitImpl* mImpl;
-
};
} // namespace Dali
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
struct Mutex::MutexImpl
{
std::mutex mutex;
- bool locked;
+ bool locked;
};
Mutex::Mutex()
-: mImpl( new MutexImpl )
+: mImpl(new MutexImpl)
{
mImpl->locked = false;
}
return mImpl->locked;
}
-Mutex::ScopedLock::ScopedLock( Mutex& mutex )
-: mMutex( mutex )
+Mutex::ScopedLock::ScopedLock(Mutex& mutex)
+: mMutex(mutex)
{
mMutex.mImpl->mutex.lock();
Internal::MutexTrace::Lock(); // matching sequence in conditional-wait.cpp
#define DALI_MUTEX_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace Dali
{
-
/**
* Class to synchronize access to critical resources from multiple threads
*/
class DALI_CORE_API Mutex
{
public:
-
/**
* @brief Constructor, acquires the mutex from the underlying OS
*/
bool IsLocked();
public:
-
/**
* Helper class to do a scoped lock on a mutex implementing the RAII idiom.
* Note! this class *does not* prevent a deadlock in the case when same thread is
class DALI_CORE_API ScopedLock
{
public:
-
/**
* Constructor
* @param mutex to lock
*/
- ScopedLock( Mutex& mutex );
+ ScopedLock(Mutex& mutex);
/**
* Destructor, releases the lock
};
private:
-
/// Not implemented as Mutex is not copyable
- Mutex( const Mutex& );
- const Mutex& operator= ( const Mutex& );
+ Mutex(const Mutex&);
+ const Mutex& operator=(const Mutex&);
struct MutexImpl;
MutexImpl* mImpl;
-
};
} // namespace Dali
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 "thread-pool.h"
#include <cmath>
-
-
namespace Dali
{
namespace
{
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
-}
+} // namespace
/**
* WorkerThread executes tasks submitted to the pool
class WorkerThread
{
public:
-
/**
* @brief Constructor of worker thread
* @param index Thread index assigned to the object during pool initialisation
*/
- explicit WorkerThread( uint32_t index );
+ explicit WorkerThread(uint32_t index);
/**
* @brief Destructor of the worker thread
*/
~WorkerThread();
- WorkerThread(const WorkerThread &other) = delete;
- WorkerThread &operator=(const WorkerThread &other) = delete;
+ WorkerThread(const WorkerThread& other) = delete;
+ WorkerThread& operator=(const WorkerThread& other) = delete;
/**
* @brief Adds task to the task queue
* @param task Task to be executed by the thread
*/
- void AddTask( Task task );
+ void AddTask(Task task);
/**
* @brief Wakes up thread.
void Wait();
private:
-
/**
* @brief Internal thread loop function
*/
void WaitAndExecute();
- std::thread mWorker;
- uint32_t mIndex;
- TaskQueue mTaskQueue;
- std::mutex mTaskQueueMutex;
+ std::thread mWorker;
+ uint32_t mIndex;
+ TaskQueue mTaskQueue;
+ std::mutex mTaskQueueMutex;
std::condition_variable mConditionVariable;
- bool mTerminating {false} ;
+ bool mTerminating{false};
};
void WorkerThread::WaitAndExecute()
{
- while( true )
+ while(true)
{
Task task;
{
- std::unique_lock< std::mutex > lock{ mTaskQueueMutex };
+ std::unique_lock<std::mutex> lock{mTaskQueueMutex};
- mConditionVariable.wait( lock, [ this ]() -> bool {
+ mConditionVariable.wait(lock, [this]() -> bool {
return !mTaskQueue.empty() || mTerminating;
- } );
+ });
- if( mTerminating )
+ if(mTerminating)
{
break;
}
task = mTaskQueue.front();
}
- task( mIndex );
+ task(mIndex);
{
- std::lock_guard< std::mutex > lock{ mTaskQueueMutex };
+ std::lock_guard<std::mutex> lock{mTaskQueueMutex};
mTaskQueue.pop();
}
}
-WorkerThread::WorkerThread(uint32_t index) : mIndex( index )
+WorkerThread::WorkerThread(uint32_t index)
+: mIndex(index)
{
// Have to pass "this" as an argument because WaitAndExecute is a member function.
- mWorker = std::thread{ &WorkerThread::WaitAndExecute, this };
+ mWorker = std::thread{&WorkerThread::WaitAndExecute, this};
}
WorkerThread::~WorkerThread()
{
- if( mWorker.joinable() )
+ if(mWorker.joinable())
{
Notify();
Wait();
{
- std::lock_guard< std::mutex > lock{ mTaskQueueMutex };
+ std::lock_guard<std::mutex> lock{mTaskQueueMutex};
mTerminating = true;
mConditionVariable.notify_one();
}
}
}
-void WorkerThread::AddTask( Task task )
+void WorkerThread::AddTask(Task task)
{
- std::lock_guard< std::mutex > lock{ mTaskQueueMutex };
- mTaskQueue.push( std::move( task ) );
+ std::lock_guard<std::mutex> lock{mTaskQueueMutex};
+ mTaskQueue.push(std::move(task));
mConditionVariable.notify_one();
}
void WorkerThread::Notify()
{
- std::lock_guard< std::mutex > lock{ mTaskQueueMutex };
+ std::lock_guard<std::mutex> lock{mTaskQueueMutex};
mConditionVariable.notify_one();
}
void WorkerThread::Wait()
{
- std::unique_lock< std::mutex > lock{ mTaskQueueMutex };
- mConditionVariable.wait( lock, [ this ]() -> bool {
+ std::unique_lock<std::mutex> lock{mTaskQueueMutex};
+ mConditionVariable.wait(lock, [this]() -> bool {
return mTaskQueue.empty();
- } );
+ });
}
// ThreadPool -----------------------------------------------------------------------------------------------
struct ThreadPool::Impl
{
std::vector<std::unique_ptr<WorkerThread>> mWorkers;
- uint32_t mWorkerIndex{ 0u };
+ uint32_t mWorkerIndex{0u};
};
ThreadPool::ThreadPool()
ThreadPool::~ThreadPool() = default;
-bool ThreadPool::Initialize( uint32_t threadCount )
+bool ThreadPool::Initialize(uint32_t threadCount)
{
/**
* Get the system's supported thread count.
*/
auto thread_count = threadCount + 1;
- if( !threadCount )
+ if(!threadCount)
{
thread_count = std::thread::hardware_concurrency();
- if( !thread_count )
+ if(!thread_count)
{
return false;
}
/**
* Spawn the worker threads.
*/
- for( auto i = 0u; i < thread_count - 1; i++ )
+ for(auto i = 0u; i < thread_count - 1; i++)
{
/**
* The workers will execute an infinite loop function
* and will wait for a job to enter the job queue. Once a job is in the the queue
* the threads will wake up to acquire and execute it.
*/
- mImpl->mWorkers.push_back( make_unique< WorkerThread >( i ) );
+ mImpl->mWorkers.push_back(make_unique<WorkerThread>(i));
}
return true;
}
-
void ThreadPool::Wait()
{
- for( auto& worker : mImpl->mWorkers )
+ for(auto& worker : mImpl->mWorkers)
{
worker->Wait();
}
}
-SharedFuture ThreadPool::SubmitTask( uint32_t workerIndex, const Task& task )
+SharedFuture ThreadPool::SubmitTask(uint32_t workerIndex, const Task& task)
{
- auto future = std::shared_ptr< Future< void > >( new Future< void > );
- mImpl->mWorkers[workerIndex]->AddTask( [task, future]( uint32_t index )
- {
- task( index );
+ auto future = std::shared_ptr<Future<void>>(new Future<void>);
+ mImpl->mWorkers[workerIndex]->AddTask([task, future](uint32_t index) {
+ task(index);
- future->mPromise.set_value();
- });
+ future->mPromise.set_value();
+ });
return future;
}
-SharedFuture ThreadPool::SubmitTasks( const std::vector< Task >& tasks )
+SharedFuture ThreadPool::SubmitTasks(const std::vector<Task>& tasks)
{
- auto future = std::shared_ptr< Future< void > >( new Future< void > );
+ auto future = std::shared_ptr<Future<void>>(new Future<void>);
- mImpl->mWorkers[ mImpl->mWorkerIndex++ % static_cast< uint32_t >( mImpl->mWorkers.size() )]->AddTask(
- [ future, tasks ]( uint32_t index ) {
- for( auto& task : tasks )
+ mImpl->mWorkers[mImpl->mWorkerIndex++ % static_cast<uint32_t>(mImpl->mWorkers.size())]->AddTask(
+ [future, tasks](uint32_t index) {
+ for(auto& task : tasks)
{
- task( index );
+ task(index);
}
future->mPromise.set_value();
-
- } );
+ });
return future;
}
-UniqueFutureGroup ThreadPool::SubmitTasks( const std::vector< Task >& tasks, uint32_t threadMask )
+UniqueFutureGroup ThreadPool::SubmitTasks(const std::vector<Task>& tasks, uint32_t threadMask)
{
auto retval = make_unique<FutureGroup<void>>();
*/
auto threads = uint32_t(std::log2(float(tasks.size())));
- if( threadMask != 0 )
+ if(threadMask != 0)
{
threads = threadMask;
}
- if( threads > mImpl->mWorkers.size() )
+ if(threads > mImpl->mWorkers.size())
{
threads = uint32_t(mImpl->mWorkers.size());
}
- else if( !threads )
+ else if(!threads)
{
threads = 1;
}
auto payloadPerThread = uint32_t(tasks.size() / threads);
- auto remaining = uint32_t(tasks.size() % threads);
+ auto remaining = uint32_t(tasks.size() % threads);
uint32_t taskIndex = 0;
- uint32_t taskSize = uint32_t(remaining + payloadPerThread); // add 'remaining' tasks to the very first job list
+ uint32_t taskSize = uint32_t(remaining + payloadPerThread); // add 'remaining' tasks to the very first job list
- for( auto wt = 0u; wt < threads; ++wt )
+ for(auto wt = 0u; wt < threads; ++wt)
{
- auto future = std::shared_ptr< Future< void > >( new Future< void > );
- retval->mFutures.emplace_back( future );
- mImpl->mWorkers[ mImpl->mWorkerIndex++ % static_cast< uint32_t >( mImpl->mWorkers.size() )]->AddTask(
- [ future, tasks, taskIndex, taskSize ]( uint32_t index ) {
+ auto future = std::shared_ptr<Future<void>>(new Future<void>);
+ retval->mFutures.emplace_back(future);
+ mImpl->mWorkers[mImpl->mWorkerIndex++ % static_cast<uint32_t>(mImpl->mWorkers.size())]->AddTask(
+ [future, tasks, taskIndex, taskSize](uint32_t index) {
auto begin = tasks.begin() + int(taskIndex);
- auto end = begin + int(taskSize);
- for( auto it = begin; it < end; ++it )
+ auto end = begin + int(taskSize);
+ for(auto it = begin; it < end; ++it)
{
- (*it)( index );
+ (*it)(index);
}
future->mPromise.set_value();
- } );
+ });
taskIndex += taskSize;
taskSize = payloadPerThread;
#define DALI_THREAD_POOL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/common/dali-common.h>
// EXTERNAL INCLUDES
-#include <thread>
-#include <functional>
-#include <mutex>
-#include <queue>
+#include <algorithm>
#include <condition_variable>
+#include <functional>
#include <future>
-#include <algorithm>
#include <iostream>
#include <memory>
+#include <mutex>
+#include <queue>
+#include <thread>
namespace Dali
{
friend class ThreadPool;
public:
-
/**
* @brief Constructor of Future
*/
*/
void Wait() const
{
- if( IsValid() )
+ if(IsValid())
{
mFuture.wait();
}
}
private:
-
std::promise<T> mPromise{};
std::future<T> mFuture{};
};
friend class ThreadPool;
public:
-
/**
* Waits for all the Futures to complete.
*/
void Wait()
{
- for (auto &future : mFutures)
+ for(auto& future : mFutures)
{
future->Wait();
}
}
private:
-
- std::vector<std::shared_ptr<Future<T> > > mFutures;
+ std::vector<std::shared_ptr<Future<T>>> mFutures;
};
using UniqueFutureGroup = std::unique_ptr<FutureGroup<void>>;
-
-
/**
* ThreadPool creates and manages worker threads and tasks submitted for execution.
*/
class DALI_CORE_API ThreadPool final
{
public:
-
/**
* @brief Constructor of thread pool.
*/
* @param threadCount Number of worker threads to use. If 0 then thread count equals hardware thread count.
* @return True if success
*/
- bool Initialize( uint32_t threadCount = 0u );
+ bool Initialize(uint32_t threadCount = 0u);
/**
* @brief Waits until all threads finish execution and go back to the idle state.
* @param task Task submitted for execution
* @return Shared pointer to the Future object
*/
- SharedFuture SubmitTask(uint32_t workerIndex, const Task &task);
+ SharedFuture SubmitTask(uint32_t workerIndex, const Task& task);
/**
* @brief Submits vector of tasks to the pool
size_t GetWorkerCount() const;
private:
-
struct Impl;
std::unique_ptr<Impl> mImpl;
};
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/devel-api/threading/thread.h>
// EXTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
#include <cstddef>
#include <thread>
-#include <dali/integration-api/debug.h>
namespace Dali
{
-
struct Thread::ThreadImpl
{
- ThreadImpl( Thread& aThis )
- : thread( &Thread::InternalThreadEntryFunc, std::ref( aThis ) )
+ ThreadImpl(Thread& aThis)
+ : thread(&Thread::InternalThreadEntryFunc, std::ref(aThis))
{
// std::thread starts execution immediately
}
- ~ThreadImpl( )
+ ~ThreadImpl()
{
thread.join();
}
};
Thread::Thread()
-: mImpl( nullptr )
+: mImpl(nullptr)
{
}
void Thread::Start()
{
- if( !mImpl )
+ if(!mImpl)
{
- mImpl = new Thread::ThreadImpl( *this );
+ mImpl = new Thread::ThreadImpl(*this);
}
}
mImpl = nullptr;
}
-void Thread::InternalThreadEntryFunc( Thread& aThis )
+void Thread::InternalThreadEntryFunc(Thread& aThis)
{
aThis.Run();
}
*/
namespace Dali
{
-
/*
* @brief Abstract class for thread functionality. Can be used for worker threads.
*/
class DALI_CORE_API Thread
{
public:
-
/**
* @brief Creates a new thread and make it executable.
*/
void Join();
protected:
-
/**
* @brief Constructor
*/
virtual void Run() = 0;
private:
-
/**
* Helper for the thread calling the entry function.
* @param[in] This A pointer to the current thread object
*/
- static void InternalThreadEntryFunc( Thread& This );
+ static void InternalThreadEntryFunc(Thread& This);
// Not copyable or movable
- Thread( const Thread& ) = delete; ///< Deleted copy constructor
- Thread( Thread&& ) = delete; ///< Deleted move constructor
- Thread& operator=( const Thread& ) = delete; ///< Deleted copy assignment operator
- Thread& operator=( Thread&& ) = delete; ///< Deleted move assignment operator
+ Thread(const Thread&) = delete; ///< Deleted copy constructor
+ Thread(Thread&&) = delete; ///< Deleted move constructor
+ Thread& operator=(const Thread&) = delete; ///< Deleted copy assignment operator
+ Thread& operator=(Thread&&) = delete; ///< Deleted move assignment operator
private:
-
struct ThreadImpl;
ThreadImpl* mImpl;
-
};
-}
+} // namespace Dali
#endif // DALI_THREAD_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
FrameCallbackInterface::FrameCallbackInterface()
-: mImpl( std::unique_ptr< Impl >( new Impl ) )
+: mImpl(std::unique_ptr<Impl>(new Impl))
{
}
FrameCallbackInterface::~FrameCallbackInterface()
{
- if( Internal::Stage::IsInstalled() )
+ if(Internal::Stage::IsInstalled())
{
Internal::StagePtr stage = Internal::Stage::GetCurrent();
- if( stage )
+ if(stage)
{
// This will be a no-op if the callback has already been removed
- stage->RemoveFrameCallback( *this );
+ stage->RemoveFrameCallback(*this);
}
}
}
#define DALI_FRAME_CALLBACK_INTERFACE_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
class UpdateProxy;
/**
class DALI_CORE_API FrameCallbackInterface
{
public:
-
/**
* @brief Called from the update-thread after the scene has been updated, and is ready to render.
* @param[in] updateProxy Use this to get/set required values for the Actor.
* @param[in] elapsedSeconds Time elapsed time since the last frame (in seconds)
* @see FrameCallbackInterface
*/
- virtual void Update( UpdateProxy& updateProxy, float elapsedSeconds ) = 0;
+ virtual void Update(UpdateProxy& updateProxy, float elapsedSeconds) = 0;
protected:
-
/**
* @brief Protected constructor.
*/
class Impl;
private:
- std::unique_ptr< Impl > mImpl;
+ std::unique_ptr<Impl> mImpl;
/// @endcond
};
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-bool UpdateProxy::GetPosition( uint32_t id, Vector3& position ) const
+bool UpdateProxy::GetPosition(uint32_t id, Vector3& position) const
{
- return mImpl.GetPosition( id, position );
+ return mImpl.GetPosition(id, position);
}
-bool UpdateProxy::SetPosition( uint32_t id, const Vector3& position )
+bool UpdateProxy::SetPosition(uint32_t id, const Vector3& position)
{
- return mImpl.SetPosition( id, position );
+ return mImpl.SetPosition(id, position);
}
-bool UpdateProxy::BakePosition( uint32_t id, const Vector3& position )
+bool UpdateProxy::BakePosition(uint32_t id, const Vector3& position)
{
- return mImpl.BakePosition( id, position );
+ return mImpl.BakePosition(id, position);
}
-bool UpdateProxy::GetSize( uint32_t id, Vector3& size ) const
+bool UpdateProxy::GetSize(uint32_t id, Vector3& size) const
{
- return mImpl.GetSize( id, size );
+ return mImpl.GetSize(id, size);
}
-bool UpdateProxy::SetSize( uint32_t id, const Vector3& size )
+bool UpdateProxy::SetSize(uint32_t id, const Vector3& size)
{
- return mImpl.SetSize( id, size );
+ return mImpl.SetSize(id, size);
}
-bool UpdateProxy::BakeSize( uint32_t id, const Vector3& size )
+bool UpdateProxy::BakeSize(uint32_t id, const Vector3& size)
{
- return mImpl.BakeSize( id, size );
+ return mImpl.BakeSize(id, size);
}
-bool UpdateProxy::GetPositionAndSize( uint32_t id, Vector3& position, Vector3& size ) const
+bool UpdateProxy::GetPositionAndSize(uint32_t id, Vector3& position, Vector3& size) const
{
- return mImpl.GetPositionAndSize( id, position, size );
+ return mImpl.GetPositionAndSize(id, position, size);
}
-bool UpdateProxy::GetScale( uint32_t id, Vector3& scale ) const
+bool UpdateProxy::GetScale(uint32_t id, Vector3& scale) const
{
- return mImpl.GetScale( id, scale );
+ return mImpl.GetScale(id, scale);
}
-bool UpdateProxy::SetScale( uint32_t id, const Vector3& scale )
+bool UpdateProxy::SetScale(uint32_t id, const Vector3& scale)
{
- return mImpl.SetScale( id, scale );
+ return mImpl.SetScale(id, scale);
}
-bool UpdateProxy::BakeScale( uint32_t id, const Vector3& scale )
+bool UpdateProxy::BakeScale(uint32_t id, const Vector3& scale)
{
- return mImpl.BakeScale( id, scale );
+ return mImpl.BakeScale(id, scale);
}
-bool UpdateProxy::GetColor( uint32_t id, Vector4& color ) const
+bool UpdateProxy::GetColor(uint32_t id, Vector4& color) const
{
- return mImpl.GetColor( id, color );
+ return mImpl.GetColor(id, color);
}
-bool UpdateProxy::SetColor( uint32_t id, const Vector4& color )
+bool UpdateProxy::SetColor(uint32_t id, const Vector4& color)
{
- return mImpl.SetColor( id, color );
+ return mImpl.SetColor(id, color);
}
-bool UpdateProxy::BakeColor( uint32_t id, const Vector4& color )
+bool UpdateProxy::BakeColor(uint32_t id, const Vector4& color)
{
- return mImpl.BakeColor( id, color );
+ return mImpl.BakeColor(id, color);
}
-UpdateProxy::UpdateProxy( Internal::UpdateProxy& impl )
-: mImpl( impl )
+UpdateProxy::UpdateProxy(Internal::UpdateProxy& impl)
+: mImpl(impl)
{
}
#define DALI_UPDATE_PROXY_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class UpdateProxy;
class DALI_CORE_API UpdateProxy
{
public:
-
/**
* @brief Given the Actor ID, this retrieves that Actor's local position.
* @param[in] id The Actor ID
* @param[out] position Set to the Actor's current position, if Actor ID is valid
* @return Whether the method call was successful or not.
*/
- bool GetPosition( uint32_t id, Vector3& position ) const;
+ bool GetPosition(uint32_t id, Vector3& position) const;
/**
* @brief Allows setting an Actor's local position from the Frame callback function for the current frame only.
* @return Whether the method call was successful or not.
* @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
*/
- bool SetPosition( uint32_t id, const Vector3& position );
+ bool SetPosition(uint32_t id, const Vector3& position);
/**
* @brief Allows baking an Actor's local position from the Frame callback function.
* @return Whether the method call was successful or not.
* @note The value is saved so will cause undesired effects if this property is being animated.
*/
- bool BakePosition( uint32_t id, const Vector3& position );
+ bool BakePosition(uint32_t id, const Vector3& position);
/**
* @brief Given the Actor ID, this retrieves that Actor's size.
* @param[out] size Set to the Actor's current size, if Actor ID is valid
* @return Whether the method call was successful or not.
*/
- bool GetSize( uint32_t id, Vector3& size ) const;
+ bool GetSize(uint32_t id, Vector3& size) const;
/**
* @brief Allows setting an Actor's size from the Frame callback function for the current frame only.
* @return Whether the method call was successful or not.
* @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
*/
- bool SetSize( uint32_t id, const Vector3& size );
+ bool SetSize(uint32_t id, const Vector3& size);
/**
* @brief Allows baking an Actor's size from the Frame callback function.
* @return Whether the method call was successful or not.
* @note The value is saved so will cause undesired effects if this property is being animated.
*/
- bool BakeSize( uint32_t id, const Vector3& size );
+ bool BakeSize(uint32_t id, const Vector3& size);
/**
* @brief Given the Actor ID, this retrieves that Actor's local position and size.
* @param[out] size Set to the Actor's current size, if Actor ID is valid
* @return Whether the method call was successful or not.
*/
- bool GetPositionAndSize( uint32_t id, Vector3& position, Vector3& size ) const;
+ bool GetPositionAndSize(uint32_t id, Vector3& position, Vector3& size) const;
/**
* @brief Given the Actor ID, this retrieves that Actor's local scale.
* @param[out] scale Set to the Actor's current scale, if Actor ID is valid
* @return Whether the method call was successful or not.
*/
- bool GetScale( uint32_t id, Vector3& scale ) const;
+ bool GetScale(uint32_t id, Vector3& scale) const;
/**
* @brief Allows setting an Actor's local scale from the Frame callback function for the current frame only.
* @return Whether the method call was successful or not.
* @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
*/
- bool SetScale( uint32_t id, const Vector3& scale );
+ bool SetScale(uint32_t id, const Vector3& scale);
/**
* @brief Allows baking an Actor's local scale from the Frame callback function.
* @return Whether the method call was successful or not.
* @note The value is saved so will cause undesired effects if this property is being animated.
*/
- bool BakeScale( uint32_t id, const Vector3& scale );
+ bool BakeScale(uint32_t id, const Vector3& scale);
/**
* @brief Given the Actor ID, this retrieves that Actor's local color.
* @param[out] color Set to the Actor's current color, if Actor ID is valid
* @return Whether the method call was successful or not.
*/
- bool GetColor( uint32_t id, Vector4& color ) const;
+ bool GetColor(uint32_t id, Vector4& color) const;
/**
* @brief Allows setting an Actor's local color from the Frame callback function for the current frame only.
* @return Whether the method call was successful or not.
* @note This will get reset to the internally calculated or previously baked value in the next frame, so will have to be set again.
*/
- bool SetColor( uint32_t id, const Vector4& color );
+ bool SetColor(uint32_t id, const Vector4& color);
/**
* @brief Allows baking an Actor's local color from the Frame callback function.
* @return Whether the method call was successful or not.
* @note The value is saved so will cause undesired effects if this property is being animated.
*/
- bool BakeColor( uint32_t id, const Vector4& color );
+ bool BakeColor(uint32_t id, const Vector4& color);
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Constructor.
* @param[in] impl A reference to the internal object.
*/
- DALI_INTERNAL UpdateProxy( Internal::UpdateProxy& impl );
+ DALI_INTERNAL UpdateProxy(Internal::UpdateProxy& impl);
/**
* @brief Destructor.
// Not copyable or movable
- UpdateProxy( const UpdateProxy& ) = delete; ///< Deleted copy constructor
- UpdateProxy( UpdateProxy&& ) = delete; ///< Deleted move constructor
- UpdateProxy& operator=( const UpdateProxy& ) = delete; ///< Deleted copy assignment operator
- UpdateProxy& operator=( UpdateProxy&& ) = delete; ///< Deleted move assignment operator
+ UpdateProxy(const UpdateProxy&) = delete; ///< Deleted copy constructor
+ UpdateProxy(UpdateProxy&&) = delete; ///< Deleted move constructor
+ UpdateProxy& operator=(const UpdateProxy&) = delete; ///< Deleted copy assignment operator
+ UpdateProxy& operator=(UpdateProxy&&) = delete; ///< Deleted move assignment operator
/// @endcond
private:
-
/// @cond internal
Internal::UpdateProxy& mImpl;
/// @endcond
{
return mSingleton;
}
-}
-}
+} // namespace Integration
+} // namespace Dali
#include <dali/public-api/object/base-handle.h>
// EXTERNAL EXCLUDES
-#include <string>
+#include <cstdio>
+#include <functional>
#include <memory>
+#include <string>
#include <vector>
-#include <functional>
-#include <cstdio>
namespace Dali
{
* @param[in] rev Revision version number
* @return returns 32-bit version number
*/
-constexpr uint32_t DALI_ADDON_VERSION( uint32_t maj, uint32_t min, uint32_t rev )
+constexpr uint32_t DALI_ADDON_VERSION(uint32_t maj, uint32_t min, uint32_t rev)
{
- return ((maj&0xff) << 24) | ((min & 0xfff) << 16);
+ return ((maj & 0xff) << 24) | ((min & 0xfff) << 16);
}
/**
*/
struct AddOnInfo
{
- AddOnType type; /// may be use in order to classify extension
- void* next; /// holds pointer to additional data-structures
+ AddOnType type; /// may be use in order to classify extension
+ void* next; /// holds pointer to additional data-structures
- std::string name; /// Name of the extension
+ std::string name; /// Name of the extension
uint32_t version;
/**
struct AddOnDispatchTable
{
std::string name;
- void (*GetAddOnInfo)( Dali::AddOnInfo&) = nullptr;
- void*(*GetGlobalProc)(const char*) = nullptr;
- void*(*GetInstanceProc)(const char*) = nullptr;
+ void (*GetAddOnInfo)(Dali::AddOnInfo&) = nullptr;
+ void* (*GetGlobalProc)(const char*) = nullptr;
+ void* (*GetInstanceProc)(const char*) = nullptr;
// Lifecycle callbacks
- void(*OnStart)() = nullptr;
- void(*OnResume)() = nullptr;
- void(*OnPause)() = nullptr;
- void(*OnStop)() = nullptr;
+ void (*OnStart)() = nullptr;
+ void (*OnResume)() = nullptr;
+ void (*OnPause)() = nullptr;
+ void (*OnStop)() = nullptr;
};
/**
AddOnManager();
public:
-
/**
* @brief Destructor
*/
* @param[out]] info Output reference
* @return True on success, False if extension info cannot be retrieved
*/
- virtual bool GetAddOnInfo(const std::string& name, AddOnInfo& info ) = 0;
+ virtual bool GetAddOnInfo(const std::string& name, AddOnInfo& info) = 0;
/**
* @brief Loads and initialises specified extensions
* @param[in] extensionNames Array of extension names
* @return vector of initialised extension handles
*/
- virtual std::vector<AddOnLibrary> LoadAddOns( const std::vector<std::string>& addonNames ) = 0;
+ virtual std::vector<AddOnLibrary> LoadAddOns(const std::vector<std::string>& addonNames) = 0;
/**
* @brief Loads AddOn with specified name
* @param[in] addOnName Name of AddOn to be acquired
* @return Returns a valid handle or nullptr
*/
- inline AddOnLibrary GetAddOn( const std::string& addonName )
+ inline AddOnLibrary GetAddOn(const std::string& addonName)
{
- return LoadAddOns( { addonName } )[0];
+ return LoadAddOns({addonName})[0];
}
/**
* @param[in] procName Name of the function to retrieve
* @return Pointer to the function or null if function doesn't exist
*/
- virtual void* GetGlobalProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName ) = 0;
+ virtual void* GetGlobalProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) = 0;
/**
* @brief Returns addon instance function pointer
* @param[in] procName Name of the function to retrieve
* @return Pointer to the function or null if function doesn't exist
*/
- virtual void* GetInstanceProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName ) = 0;
+ virtual void* GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName) = 0;
/**
* @brief Returns addon global function of specified type
* @return std::function object or null if function doesn't exist
*/
template<class T>
- DALI_INTERNAL std::function<T> GetGlobalProc( const Dali::AddOnLibrary& addonlibrary, const char* procName )
+ DALI_INTERNAL std::function<T> GetGlobalProc(const Dali::AddOnLibrary& addonlibrary, const char* procName)
{
- auto ptr = GetGlobalProc( addonlibrary, procName );
- if( ptr )
+ auto ptr = GetGlobalProc(addonlibrary, procName);
+ if(ptr)
{
- return std::function<T>( *reinterpret_cast<T**>(&ptr) );
+ return std::function<T>(*reinterpret_cast<T**>(&ptr));
}
return {};
};
* @return std::function object or null if function doesn't exist
*/
template<class T>
- DALI_INTERNAL std::function<T> GetInstanceProc( const Dali::AddOnLibrary& addOnLibrary, const char* procName )
+ DALI_INTERNAL std::function<T> GetInstanceProc(const Dali::AddOnLibrary& addOnLibrary, const char* procName)
{
- auto ptr = GetInstanceProc( addOnLibrary, procName );
- if( ptr )
+ auto ptr = GetInstanceProc(addOnLibrary, procName);
+ if(ptr)
{
- return std::function<T>( *reinterpret_cast<T**>(&ptr) );
+ return std::function<T>(*reinterpret_cast<T**>(&ptr));
}
return {};
};
* @return Result of called function
*/
template<class R, class... Args>
- DALI_INTERNAL R InvokeGlobalProc( AddOnLibrary addOnLibrary, const char* functionName, Args&&... args)
+ DALI_INTERNAL R InvokeGlobalProc(AddOnLibrary addOnLibrary, const char* functionName, Args&&... args)
{
- return std::move(GetGlobalProc<R(Args...)>( addOnLibrary, functionName )( args... ));
+ return std::move(GetGlobalProc<R(Args...)>(addOnLibrary, functionName)(args...));
}
// Lifecycle events, functions are called by the Adaptor
public:
-
/**
* @brief Lifecycle pause function
*/
// Functions called by the AddOn
public:
-
/**
* @brief Registers the dispatch table with AddOnManager.
*
*
* @param[in] dispatchTable Pointer to the valid dispatch table
*/
- virtual void RegisterAddOnDispatchTable( const AddOnDispatchTable* dispatchTable ) = 0;
+ virtual void RegisterAddOnDispatchTable(const AddOnDispatchTable* dispatchTable) = 0;
/**
* @brief Retrieves AddOnManager singleton
static AddOnManager* Get();
protected:
-
static AddOnManager* mSingleton; ///< Singleton storing an instance of AddOnManager
};
} // namespace Integration
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/gl-abstraction.h>
+#include <dali/integration-api/gl-defines.h>
#include <dali/integration-api/platform-abstraction.h>
#include <dali/internal/event/common/thread-local-storage.h>
-#include <dali/internal/event/images/bitmap-packed-pixel.h>
#include <dali/internal/event/images/bitmap-compressed.h>
-#include <dali/integration-api/gl-abstraction.h>
-#include <dali/integration-api/gl-defines.h>
+#include <dali/internal/event/images/bitmap-packed-pixel.h>
namespace Dali
{
-
namespace Integration
{
using namespace Dali::Pixel;
-void ConvertToGlFormat( Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat )
+void ConvertToGlFormat(Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat)
{
// Compressed textures have no pixelDataType, so init to an invalid value:
- pixelDataType = -1;
+ pixelDataType = -1;
- switch( pixelformat )
+ switch(pixelformat)
{
case A8:
{
- pixelDataType = GL_UNSIGNED_BYTE;
- internalFormat= GL_ALPHA;
+ pixelDataType = GL_UNSIGNED_BYTE;
+ internalFormat = GL_ALPHA;
break;
}
case L8:
{
- pixelDataType = GL_UNSIGNED_BYTE;
- internalFormat= GL_LUMINANCE;
+ pixelDataType = GL_UNSIGNED_BYTE;
+ internalFormat = GL_LUMINANCE;
break;
}
case LA88:
{
- pixelDataType = GL_UNSIGNED_BYTE;
- internalFormat= GL_LUMINANCE_ALPHA;
+ pixelDataType = GL_UNSIGNED_BYTE;
+ internalFormat = GL_LUMINANCE_ALPHA;
break;
}
case RGB565:
{
- pixelDataType = GL_UNSIGNED_SHORT_5_6_5;
- internalFormat= GL_RGB;
+ pixelDataType = GL_UNSIGNED_SHORT_5_6_5;
+ internalFormat = GL_RGB;
break;
}
case BGR565:
{
DALI_LOG_ERROR("Pixel format BGR565 is not supported by GLES.\n");
- pixelDataType = GL_UNSIGNED_SHORT_5_6_5;
+ pixelDataType = GL_UNSIGNED_SHORT_5_6_5;
#ifdef _ARCH_ARM_
- internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
+ internalFormat = GL_BGRA_EXT; // alpha is reserved but not used
#else
- internalFormat= GL_RGBA; // alpha is reserved but not used
+ internalFormat = GL_RGBA; // alpha is reserved but not used
#endif
break;
}
case RGBA4444:
{
- pixelDataType = GL_UNSIGNED_SHORT_4_4_4_4;
- internalFormat= GL_RGBA;
+ pixelDataType = GL_UNSIGNED_SHORT_4_4_4_4;
+ internalFormat = GL_RGBA;
break;
}
case BGRA4444:
{
DALI_LOG_ERROR("Pixel format BGRA4444 is not supported by GLES.\n");
- pixelDataType = GL_UNSIGNED_SHORT_4_4_4_4;
+ pixelDataType = GL_UNSIGNED_SHORT_4_4_4_4;
#ifdef _ARCH_ARM_
- internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
+ internalFormat = GL_BGRA_EXT; // alpha is reserved but not used
#else
- internalFormat= GL_RGBA; // alpha is reserved but not used
+ internalFormat = GL_RGBA; // alpha is reserved but not used
#endif
break;
}
case RGBA5551:
{
- pixelDataType = GL_UNSIGNED_SHORT_5_5_5_1;
- internalFormat= GL_RGBA;
+ pixelDataType = GL_UNSIGNED_SHORT_5_5_5_1;
+ internalFormat = GL_RGBA;
break;
}
case BGRA5551:
{
DALI_LOG_ERROR("Pixel format BGRA5551 is not supported by GLES.\n");
- pixelDataType = GL_UNSIGNED_SHORT_5_5_5_1;
+ pixelDataType = GL_UNSIGNED_SHORT_5_5_5_1;
#ifdef _ARCH_ARM_
- internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
+ internalFormat = GL_BGRA_EXT; // alpha is reserved but not used
#else
- internalFormat= GL_RGBA; // alpha is reserved but not used
+ internalFormat = GL_RGBA; // alpha is reserved but not used
#endif
break;
}
case RGB888:
{
- pixelDataType = GL_UNSIGNED_BYTE;
- internalFormat= GL_RGB;
+ pixelDataType = GL_UNSIGNED_BYTE;
+ internalFormat = GL_RGB;
break;
}
case RGB8888:
{
- pixelDataType = GL_UNSIGNED_BYTE;
- internalFormat= GL_RGBA; // alpha is reserved but not used
+ pixelDataType = GL_UNSIGNED_BYTE;
+ internalFormat = GL_RGBA; // alpha is reserved but not used
break;
}
{
pixelDataType = GL_UNSIGNED_BYTE;
#ifdef GL_BGRA_EXT
- internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
+ internalFormat = GL_BGRA_EXT; // alpha is reserved but not used
#else
- internalFormat= GL_RGBA; // alpha is reserved but not used
+ internalFormat = GL_RGBA; // alpha is reserved but not used
#endif
- break;
+ break;
}
case RGBA8888:
{
- pixelDataType = GL_UNSIGNED_BYTE;
- internalFormat= GL_RGBA;
+ pixelDataType = GL_UNSIGNED_BYTE;
+ internalFormat = GL_RGBA;
break;
}
{
pixelDataType = GL_UNSIGNED_BYTE;
#ifdef GL_BGRA_EXT
- internalFormat= GL_BGRA_EXT; // alpha is reserved but not used
+ internalFormat = GL_BGRA_EXT; // alpha is reserved but not used
#else
- internalFormat= GL_RGBA; // alpha is reserved but not used
+ internalFormat = GL_RGBA; // alpha is reserved but not used
#endif
break;
}
// GLES 2 extension compressed formats:
case COMPRESSED_RGB8_ETC1:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB8_ETC1.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB8_ETC1.\n");
internalFormat = 0x8D64; ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
break;
}
case COMPRESSED_RGB_PVRTC_4BPPV1:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB_PVRTC_4BPPV1.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using non-standard GLES 2.0 extension compressed pixel format COMPRESSED_RGB_PVRTC_4BPPV1.\n");
internalFormat = 0x8C00; ///! < Hardcoded so we can test before we move to GLES 3.0 or greater.
break;
}
}
case COMPRESSED_SIGNED_R11_EAC:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_R11_EAC.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_R11_EAC.\n");
internalFormat = GL_COMPRESSED_SIGNED_R11_EAC;
break;
}
case COMPRESSED_RG11_EAC:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RG11_EAC.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RG11_EAC.\n");
internalFormat = GL_COMPRESSED_RG11_EAC;
break;
}
case COMPRESSED_SIGNED_RG11_EAC:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_RG11_EAC.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SIGNED_RG11_EAC.\n");
internalFormat = GL_COMPRESSED_SIGNED_RG11_EAC;
break;
}
case COMPRESSED_RGB8_ETC2:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_ETC2.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_ETC2.\n");
internalFormat = GL_COMPRESSED_RGB8_ETC2;
break;
}
case COMPRESSED_SRGB8_ETC2:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ETC2.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ETC2.\n");
internalFormat = GL_COMPRESSED_SRGB8_ETC2;
break;
}
case COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2.\n");
internalFormat = GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
break;
}
case COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2.\n");
internalFormat = GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2;
break;
}
case COMPRESSED_RGBA8_ETC2_EAC:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGBA8_ETC2_EAC.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_RGBA8_ETC2_EAC.\n");
internalFormat = GL_COMPRESSED_RGBA8_ETC2_EAC;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ETC2_EAC.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ETC2_EAC.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;
break;
}
// GLES 3.1 extension compressed formats:
case COMPRESSED_RGBA_ASTC_4x4_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_4x4_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_4x4_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_4x4_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_5x4_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x4_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x4_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_5x4_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_5x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_5x5_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_5x5_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_6x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x5_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_6x5_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_6x6_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x6_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_6x6_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_6x6_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_8x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x5_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_8x5_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_8x6_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x6_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x6_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_8x6_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_8x8_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x8_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_8x8_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_8x8_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_10x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x5_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_10x5_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_10x6_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x6_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x6_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_10x6_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_10x8_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x8_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x8_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_10x8_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_10x10_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x10_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_10x10_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_10x10_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_12x10_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x10_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x10_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_12x10_KHR;
break;
}
case COMPRESSED_RGBA_ASTC_12x12_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x12_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_RGBA_ASTC_12x12_KHR.\n");
internalFormat = GL_COMPRESSED_RGBA_ASTC_12x12_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR;
break;
}
case COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR.\n" );
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.1 standard compressed pixel format COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR.\n");
internalFormat = GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR;
break;
}
// GLES 3.0 floating point formats.
case RGB16F:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 GLES 3.0 floating point format.\n" );
- pixelDataType = GL_HALF_FLOAT;
- internalFormat= GL_RGB;
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 GLES 3.0 floating point format.\n");
+ pixelDataType = GL_HALF_FLOAT;
+ internalFormat = GL_RGB;
break;
}
case RGB32F:
{
- DALI_LOG_INFO( Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 GLES 3.0 floating point format.\n" );
- pixelDataType = GL_FLOAT;
- internalFormat= GL_RGB;
+ DALI_LOG_INFO(Debug::Filter::gImage, Debug::Verbose, "Using GLES 3.0 GLES 3.0 floating point format.\n");
+ pixelDataType = GL_FLOAT;
+ internalFormat = GL_RGB;
break;
}
// GLES 3.0 depth and stencil formats
case Pixel::DEPTH_UNSIGNED_INT:
{
- pixelDataType = GL_UNSIGNED_INT;
+ pixelDataType = GL_UNSIGNED_INT;
internalFormat = GL_DEPTH_COMPONENT;
break;
}
case Pixel::DEPTH_FLOAT:
{
- pixelDataType = GL_FLOAT;
+ pixelDataType = GL_FLOAT;
internalFormat = GL_DEPTH_COMPONENT;
break;
}
case Pixel::DEPTH_STENCIL:
{
- pixelDataType = GL_UNSIGNED_INT_24_8;
+ pixelDataType = GL_UNSIGNED_INT_24_8;
internalFormat = GL_DEPTH_STENCIL;
break;
}
case INVALID:
{
- DALI_LOG_ERROR( "Invalid pixel format for bitmap\n" );
+ DALI_LOG_ERROR("Invalid pixel format for bitmap\n");
internalFormat = 0;
break;
}
}
}
-Bitmap* Bitmap::New( const Profile profile = BITMAP_2D_PACKED_PIXELS,
- ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_DISCARD )
+Bitmap* Bitmap::New(const Profile profile = BITMAP_2D_PACKED_PIXELS,
+ ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_DISCARD)
{
DALI_ASSERT_DEBUG(profile == BITMAP_2D_PACKED_PIXELS || profile == BITMAP_COMPRESSED);
- switch( profile )
+ switch(profile)
{
/** A 2D array of pixels where each pixel is a whole number of bytes
* and each scanline of the backing memory buffer may have additional
* scanlines past the bottom of the image in the buffer if requested.*/
case BITMAP_2D_PACKED_PIXELS:
{
- Bitmap * const bitmap = new Dali::Internal::BitmapPackedPixel( discardable );
+ Bitmap* const bitmap = new Dali::Internal::BitmapPackedPixel(discardable);
return bitmap;
}
/** The data for the bitmap is buffered in an opaque form.*/
case BITMAP_COMPRESSED:
{
- return new Dali::Internal::BitmapCompressed( discardable );
+ return new Dali::Internal::BitmapCompressed(discardable);
}
}
- return 0;
+ return nullptr;
}
-
-Bitmap::Bitmap( ResourcePolicy::Discardable discardable, Dali::Integration::PixelBuffer* pixBuf)
+Bitmap::Bitmap(ResourcePolicy::Discardable discardable, Dali::Integration::PixelBuffer* pixBuf)
: mImageWidth(0),
mImageHeight(0),
mPixelFormat(Pixel::RGBA8888),
PixelBuffer* Bitmap::GetBufferOwnership()
{
PixelBuffer* buffer = mData;
- mData = NULL;
+ mData = nullptr;
return buffer;
}
void Bitmap::DiscardBuffer()
{
- if( mDiscardable == ResourcePolicy::OWNED_DISCARD )
+ if(mDiscardable == ResourcePolicy::OWNED_DISCARD)
{
DeletePixelBuffer();
}
* */
void Bitmap::DeletePixelBuffer()
{
- if( !mData )
+ if(!mData)
{
return;
}
- free ( mData );
- mData = NULL;
+ free(mData);
+ mData = nullptr;
}
-
-void Bitmap::Initialize( Pixel::Format pixelFormat,
- unsigned int width,
- unsigned int height)
+void Bitmap::Initialize(Pixel::Format pixelFormat,
+ unsigned int width,
+ unsigned int height)
{
DALI_ASSERT_DEBUG(width * height < (32 * 1024) * (32 * 1024) && "The total area of the bitmap is too great.\n");
- mImageWidth = width;
- mImageHeight = height;
- mPixelFormat = pixelFormat;
+ mImageWidth = width;
+ mImageHeight = height;
+ mPixelFormat = pixelFormat;
mHasAlphaChannel = Pixel::HasAlpha(pixelFormat);
}
#define DALI_INTEGRATION_BITMAP_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/integration-api/debug.h>
+#include <dali/integration-api/resource-policies.h>
#include <dali/public-api/common/intrusive-ptr.h>
#include <dali/public-api/images/pixel.h>
#include <dali/public-api/object/ref-object.h>
-#include <dali/integration-api/resource-policies.h>
namespace Dali
{
-
namespace Integration
{
-
/**
* Returns GL data type and internal format for specified pixel format
* @param[in] pixelformat pixel format (eg. Pixel::RGBA32)
DALI_CORE_API void ConvertToGlFormat(Pixel::Format pixelformat, unsigned& pixelDataType, unsigned& internalFormat);
class Bitmap;
-typedef IntrusivePtr<Bitmap> BitmapPtr;
-typedef uint8_t PixelBuffer; ///< Pixel data buffers are composed of these
+using BitmapPtr = IntrusivePtr<Bitmap>;
+using PixelBuffer = uint8_t; ///< Pixel data buffers are composed of these
/**
* Bitmap class.
class DALI_CORE_API Bitmap : public Dali::RefObject
{
protected:
-
/**
* Constructor
* Use the static function Bitmap::New() to create instances.
* @param[in] discardable Flag to tell the bitmap if it can delete the buffer with the pixel data.
* @param[in] pixBuf External buffer of pixel data or null.
*/
- Bitmap( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
+ Bitmap(ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = nullptr);
/**
* Initializes internal class members
* @param[in] height Image height in pixels
*/
void Initialize(Pixel::Format pixelFormat,
- uint32_t width,
- uint32_t height);
-
+ uint32_t width,
+ uint32_t height);
public:
/** Defines the characteristics of the Bitmap returned from the factory
enum ReleaseFunction
{
- FREE, ///< Use free function to release the buffer
- DELETE_ARRAY, ///< Use delete[] operator to release the buffer
+ FREE, ///< Use free function to release the buffer
+ DELETE_ARRAY, ///< Use delete[] operator to release the buffer
};
/**
* OWNED_RETAIN means that the data is owned and must be kept in CPU memory
* e.g. for an image that cannot be reloaded from disk.
*/
- static Bitmap* New( Profile profile, ResourcePolicy::Discardable discardable );
+ static Bitmap* New(Profile profile, ResourcePolicy::Discardable discardable);
/** \name GeneralFeatures
* Features that are generic between profiles. */
/**@}*/ ///< End of generic features
-
/** \name PackedPixelsProfile
* Features that are active only if the Bitmap was created with a
* BITMAP_2D_PACKED_PIXELS profile. */
class PackedPixelsProfile
{
public:
-
/**
* (Re-)Allocate pixel buffer for the Bitmap. Any previously allocated pixel buffer is deleted.
* Dali has ownership of the buffer, but its contents can be modified.
* @return pixel buffer pointer
*/
virtual PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
- uint32_t width,
- uint32_t height,
- uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0) = 0;
+ uint32_t width,
+ uint32_t height,
+ uint32_t bufferWidth = 0,
+ uint32_t bufferHeight = 0) = 0;
/**
* Assign a pixel buffer. Any previously allocated pixel buffer is deleted.
* @param[in] bufferHeight Buffer height in pixels
*/
virtual void AssignBuffer(Pixel::Format pixelFormat,
- PixelBuffer* buffer,
- uint32_t bufferSize,
- uint32_t width,
- uint32_t height,
- uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0) = 0;
+ PixelBuffer* buffer,
+ uint32_t bufferSize,
+ uint32_t width,
+ uint32_t height,
+ uint32_t bufferWidth = 0,
+ uint32_t bufferHeight = 0) = 0;
/**
* Get the width of the buffer (stride)
* @return The width of the buffer in pixels
virtual void TestForTransparency() = 0;
protected:
-
/**
* Virtual destructor, no deletion through this interface
*/
- virtual ~PackedPixelsProfile() {}
+ virtual ~PackedPixelsProfile()
+ {
+ }
};
/**
* Get interface to features that are active only if the Bitmap was created
* with a BITMAP_2D_PACKED_PIXELS profile. */
- virtual const PackedPixelsProfile* GetPackedPixelsProfile() const { return 0; }
+ virtual const PackedPixelsProfile* GetPackedPixelsProfile() const
+ {
+ return nullptr;
+ }
/**
* Get interface to features that are active only if the Bitmap was created
* with a BITMAP_2D_PACKED_PIXELS profile. */
- virtual PackedPixelsProfile* GetPackedPixelsProfile() { return 0; }
+ virtual PackedPixelsProfile* GetPackedPixelsProfile()
+ {
+ return nullptr;
+ }
/**@}*/ ///< End of packed pixel features.
-
/** \name CompressedProfile
* Features that only apply to opaque/compressed formats. */
/**@{*/
* @param[in] bufferSize Buffer size in bytes
* @return pixel buffer pointer
*/
- virtual PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
- const unsigned width,
- const unsigned height,
- const uint32_t numBytes ) = 0;
- protected:
+ virtual PixelBuffer* ReserveBufferOfSize(Pixel::Format pixelFormat,
+ const unsigned width,
+ const unsigned height,
+ const uint32_t numBytes) = 0;
+ protected:
/**
* Virtual destructor, no deletion through this interface
*/
- virtual ~CompressedProfile() {}
+ virtual ~CompressedProfile()
+ {
+ }
};
- virtual const CompressedProfile* GetCompressedProfile() const { return 0; }
- virtual CompressedProfile* GetCompressedProfile() { return 0; }
+ virtual const CompressedProfile* GetCompressedProfile() const
+ {
+ return nullptr;
+ }
+ virtual CompressedProfile* GetCompressedProfile()
+ {
+ return nullptr;
+ }
/**@}*/
-
/**
* Inform the bitmap that its pixel buffer is no longer required and can be
* deleted to free up memory if the bitmap owns the buffer.
void DeletePixelBuffer();
protected:
-
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Bitmap();
+ ~Bitmap() override;
protected:
-
- uint32_t mImageWidth; ///< Image width in pixels
- uint32_t mImageHeight; ///< Image height in pixels
- Pixel::Format mPixelFormat; ///< Pixel format
- bool mHasAlphaChannel; ///< Whether the image has an alpha channel
- bool mAlphaChannelUsed; ///< Whether the alpha channel is used in case the image owns one.
- PixelBuffer* mData; ///< Raw pixel data
+ uint32_t mImageWidth; ///< Image width in pixels
+ uint32_t mImageHeight; ///< Image height in pixels
+ Pixel::Format mPixelFormat; ///< Pixel format
+ bool mHasAlphaChannel; ///< Whether the image has an alpha channel
+ bool mAlphaChannelUsed; ///< Whether the alpha channel is used in case the image owns one.
+ PixelBuffer* mData; ///< Raw pixel data
private:
-
ResourcePolicy::Discardable mDiscardable; ///< Should delete the buffer when discard buffer is called.
- Bitmap(const Bitmap& other); ///< defined private to prevent use
- Bitmap& operator = (const Bitmap& other); ///< defined private to prevent use
+ Bitmap(const Bitmap& other); ///< defined private to prevent use
+ Bitmap& operator=(const Bitmap& other); ///< defined private to prevent use
// Changes scope, should be at end of class
DALI_LOG_OBJECT_STRING_DECLARATION;
#define DALI_INTEGRATION_CONTEXT_NOTIFIER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
namespace Integration
{
-
/**
* Interface to inform dali core of context loss and regain
*/
virtual void NotifyContextRegained() = 0;
protected:
-
/**
* Virtual destructor, no deletion through this interface
*/
- virtual ~ContextNotifierInterface() {}
-
+ virtual ~ContextNotifierInterface()
+ {
+ }
};
} // namespace Integration
} // namespace Dali
-
#endif // DALI_INTEGRATION_CONTEXT_NOTIFIER_H
#define DALI_INTEGRATION_CORE_ENUMERATIONS_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/integration-api/context-notifier.h>
#include <dali/integration-api/resource-policies.h>
+#include <dali/public-api/common/dali-common.h>
#undef FALSE
#undef TRUE
namespace Dali
{
-
namespace Integration
{
-
/**
* @brief Enumerations to specify whether we should render to the frame-buffer.
*/
#include <dali/integration-api/core.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/actors/layer.h>
-#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/integration-api/events/event.h>
-#include <dali/integration-api/gl-sync-abstraction.h>
#include <dali/integration-api/gl-context-helper-abstraction.h>
+#include <dali/integration-api/gl-sync-abstraction.h>
#include <dali/integration-api/processor-interface.h>
#include <dali/internal/common/core-impl.h>
+#include <dali/public-api/actors/layer.h>
+#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/render-tasks/render-task-list.h>
namespace Dali
{
-
namespace Integration
{
-
-Core* Core::New( RenderController& renderController,
- PlatformAbstraction& platformAbstraction,
- GlAbstraction& glAbstraction,
- GlSyncAbstraction& glSyncAbstraction,
- GlContextHelperAbstraction& glContextHelperAbstraction,
- RenderToFrameBuffer renderToFboEnabled,
- DepthBufferAvailable depthBufferAvailable,
- StencilBufferAvailable stencilBufferAvailable,
- PartialUpdateAvailable partialUpdateAvailable )
-{
- Core* instance = new Core;
- instance->mImpl = new Internal::Core( renderController,
- platformAbstraction,
- glAbstraction,
- glSyncAbstraction,
- glContextHelperAbstraction,
- renderToFboEnabled,
- depthBufferAvailable,
- stencilBufferAvailable,
- partialUpdateAvailable );
+Core* Core::New(RenderController& renderController,
+ PlatformAbstraction& platformAbstraction,
+ GlAbstraction& glAbstraction,
+ GlSyncAbstraction& glSyncAbstraction,
+ GlContextHelperAbstraction& glContextHelperAbstraction,
+ RenderToFrameBuffer renderToFboEnabled,
+ DepthBufferAvailable depthBufferAvailable,
+ StencilBufferAvailable stencilBufferAvailable,
+ PartialUpdateAvailable partialUpdateAvailable)
+{
+ Core* instance = new Core;
+ instance->mImpl = new Internal::Core(renderController,
+ platformAbstraction,
+ glAbstraction,
+ glSyncAbstraction,
+ glContextHelperAbstraction,
+ renderToFboEnabled,
+ depthBufferAvailable,
+ stencilBufferAvailable,
+ partialUpdateAvailable);
return instance;
}
return mImpl->GetMaximumUpdateCount();
}
-void Core::Update( float elapsedSeconds, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds, UpdateStatus& status, bool renderToFboEnabled, bool isRenderingToFbo )
+void Core::Update(float elapsedSeconds, uint32_t lastVSyncTimeMilliseconds, uint32_t nextVSyncTimeMilliseconds, UpdateStatus& status, bool renderToFboEnabled, bool isRenderingToFbo)
{
- mImpl->Update( elapsedSeconds, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds, status, renderToFboEnabled, isRenderingToFbo );
+ mImpl->Update(elapsedSeconds, lastVSyncTimeMilliseconds, nextVSyncTimeMilliseconds, status, renderToFboEnabled, isRenderingToFbo);
}
-void Core::PreRender( RenderStatus& status, bool forceClear, bool uploadOnly )
+void Core::PreRender(RenderStatus& status, bool forceClear, bool uploadOnly)
{
- mImpl->PreRender( status, forceClear, uploadOnly );
+ mImpl->PreRender(status, forceClear, uploadOnly);
}
-void Core::PreRender( Integration::Scene& scene, std::vector<Rect<int>>& damagedRects )
+void Core::PreRender(Integration::Scene& scene, std::vector<Rect<int>>& damagedRects)
{
- mImpl->PreRender( scene, damagedRects );
+ mImpl->PreRender(scene, damagedRects);
}
-void Core::RenderScene( RenderStatus& status, Integration::Scene& scene, bool renderToFbo )
+void Core::RenderScene(RenderStatus& status, Integration::Scene& scene, bool renderToFbo)
{
- mImpl->RenderScene( status, scene, renderToFbo );
+ mImpl->RenderScene(status, scene, renderToFbo);
}
-void Core::RenderScene( RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect )
+void Core::RenderScene(RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect)
{
- mImpl->RenderScene( status, scene, renderToFbo, clippingRect );
+ mImpl->RenderScene(status, scene, renderToFbo, clippingRect);
}
-void Core::PostRender( bool uploadOnly )
+void Core::PostRender(bool uploadOnly)
{
- mImpl->PostRender( uploadOnly );
+ mImpl->PostRender(uploadOnly);
}
-void Core::RegisterProcessor( Processor& processor )
+void Core::RegisterProcessor(Processor& processor)
{
- mImpl->RegisterProcessor( processor );
+ mImpl->RegisterProcessor(processor);
}
-void Core::UnregisterProcessor( Processor& processor )
+void Core::UnregisterProcessor(Processor& processor)
{
- mImpl->UnregisterProcessor( processor );
+ mImpl->UnregisterProcessor(processor);
}
ObjectRegistry Core::GetObjectRegistry() const
{
- return ObjectRegistry( &mImpl->GetObjectRegistry() );
+ return ObjectRegistry(&mImpl->GetObjectRegistry());
}
Core::Core()
-: mImpl( NULL )
+: mImpl(nullptr)
{
}
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
+#include <dali/integration-api/context-notifier.h>
+#include <dali/integration-api/core-enumerations.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/math/rect.h>
-#include <dali/integration-api/context-notifier.h>
-#include <dali/integration-api/core-enumerations.h>
namespace Dali
{
-
class Layer;
class ObjectRegistry;
class RenderTaskList;
struct Event;
struct TouchEvent;
-
/**
* The reasons why further updates are required.
*/
{
enum Reasons
{
- NOT_REQUESTED = 0, ///< Zero means that no further updates are required
- STAGE_KEEP_RENDERING = 1<<1, ///< - Stage::KeepRendering() is being used
- ANIMATIONS_RUNNING = 1<<2, ///< - Animations are ongoing
- MONITORING_PERFORMANCE = 1<<3, ///< - The --enable-performance-monitor option is being used
- RENDER_TASK_SYNC = 1<<4 ///< - A render task is waiting for render sync
+ NOT_REQUESTED = 0, ///< Zero means that no further updates are required
+ STAGE_KEEP_RENDERING = 1 << 1, ///< - Stage::KeepRendering() is being used
+ ANIMATIONS_RUNNING = 1 << 2, ///< - Animations are ongoing
+ MONITORING_PERFORMANCE = 1 << 3, ///< - The --enable-performance-monitor option is being used
+ RENDER_TASK_SYNC = 1 << 4 ///< - A render task is waiting for render sync
};
}
class UpdateStatus
{
public:
-
/**
* Constructor
*/
: keepUpdating(false),
needsNotification(false),
surfaceRectChanged(false),
- secondsFromLastFrame( 0.0f )
+ secondsFromLastFrame(0.0f)
{
}
public:
-
/**
* Query whether the Core has further frames to update & render e.g. when animations are ongoing.
* @return A bitmask of KeepUpdating values
*/
- uint32_t KeepUpdating() { return keepUpdating; }
+ uint32_t KeepUpdating()
+ {
+ return keepUpdating;
+ }
/**
* Query whether the Core requires an Notification event.
* This should be sent through the same mechanism (e.g. event loop) as input events.
* @return True if an Notification event should be sent.
*/
- bool NeedsNotification() { return needsNotification; }
+ bool NeedsNotification()
+ {
+ return needsNotification;
+ }
/**
* Query wheter the default surface rect is changed or not.
* @return true if the default surface rect is changed.
*/
- bool SurfaceRectChanged() { return surfaceRectChanged; }
+ bool SurfaceRectChanged()
+ {
+ return surfaceRectChanged;
+ }
/**
* This method is provided so that FPS can be easily calculated with a release version
* of Core.
* @return the seconds from last frame as float
*/
- float SecondsFromLastFrame() { return secondsFromLastFrame; }
+ float SecondsFromLastFrame()
+ {
+ return secondsFromLastFrame;
+ }
public:
-
uint32_t keepUpdating; ///< A bitmask of KeepUpdating values
- bool needsNotification;
- bool surfaceRectChanged;
- float secondsFromLastFrame;
+ bool needsNotification;
+ bool surfaceRectChanged;
+ float secondsFromLastFrame;
};
/**
class RenderStatus
{
public:
-
/**
* Constructor
*/
RenderStatus()
- : needsUpdate( false ),
- needsPostRender( false )
+ : needsUpdate(false),
+ needsPostRender(false)
{
}
* Set whether update needs to run following a render.
* @param[in] updateRequired Set to true if an update is required to be run
*/
- void SetNeedsUpdate( bool updateRequired )
+ void SetNeedsUpdate(bool updateRequired)
{
needsUpdate = updateRequired;
}
* If nothing is rendered this frame, we can skip post-render.
* @param[in] postRenderRequired Set to True if post-render is required to be run
*/
- void SetNeedsPostRender( bool postRenderRequired )
+ void SetNeedsPostRender(bool postRenderRequired)
{
needsPostRender = postRenderRequired;
}
}
private:
-
- bool needsUpdate :1; ///< True if update is required to be run
- bool needsPostRender :1; ///< True if post-render is required to be run.
+ bool needsUpdate : 1; ///< True if update is required to be run
+ bool needsPostRender : 1; ///< True if post-render is required to be run.
};
-
/**
* Integration::Core is used for integration with the native windowing system.
* The following integration tasks must be completed:
class DALI_CORE_API Core
{
public:
-
/**
* Create a new Core.
* This object is used for integration with the native windowing system.
* @param[in] partialUpdateAvailable Whether the partial update is available
* @return A newly allocated Core.
*/
- static Core* New( RenderController& renderController,
- PlatformAbstraction& platformAbstraction,
- GlAbstraction& glAbstraction,
- GlSyncAbstraction& glSyncAbstraction,
- GlContextHelperAbstraction& glContextHelperAbstraction,
- RenderToFrameBuffer renderToFboEnabled,
- DepthBufferAvailable depthBufferAvailable,
- StencilBufferAvailable stencilBufferAvailable,
- PartialUpdateAvailable partialUpdateAvailable);
+ static Core* New(RenderController& renderController,
+ PlatformAbstraction& platformAbstraction,
+ GlAbstraction& glAbstraction,
+ GlSyncAbstraction& glSyncAbstraction,
+ GlContextHelperAbstraction& glContextHelperAbstraction,
+ RenderToFrameBuffer renderToFboEnabled,
+ DepthBufferAvailable depthBufferAvailable,
+ StencilBufferAvailable stencilBufferAvailable,
+ PartialUpdateAvailable partialUpdateAvailable);
/**
* Non-virtual destructor. Core is not intended as a base class.
* @param[in] renderToFboEnabled Whether rendering into the Frame Buffer Object is enabled.
* @param[in] isRenderingToFbo Whether this frame is being rendered into the Frame Buffer Object.
*/
- void Update( float elapsedSeconds,
- uint32_t lastVSyncTimeMilliseconds,
- uint32_t nextVSyncTimeMilliseconds,
- UpdateStatus& status,
- bool renderToFboEnabled,
- bool isRenderingToFbo );
+ void Update(float elapsedSeconds,
+ uint32_t lastVSyncTimeMilliseconds,
+ uint32_t nextVSyncTimeMilliseconds,
+ UpdateStatus& status,
+ bool renderToFboEnabled,
+ bool isRenderingToFbo);
/**
* This is called before rendering any scene in the next frame. This method should be preceded
* @param[in] forceClear force the Clear on the framebuffer even if nothing is rendered.
* @param[in] uploadOnly uploadOnly Upload the resource only without rendering.
*/
- void PreRender( RenderStatus& status, bool forceClear, bool uploadOnly );
+ void PreRender(RenderStatus& status, bool forceClear, bool uploadOnly);
/**
* This is called before rendering any scene in the next frame. This method should be preceded
* @param[in] scene The scene to be rendered.
* @param[out] damagedRects containing damaged render items rects for this pass.
*/
- void PreRender( Integration::Scene& scene, std::vector<Rect<int>>& damagedRects );
+ void PreRender(Integration::Scene& scene, std::vector<Rect<int>>& damagedRects);
/**
* Render a scene in the next frame. This method should be preceded by a call up PreRender.
* @param[in] scene The scene to be rendered.
* @param[in] renderToFbo True to render off-screen frame buffers only if any, and False to render the surface only.
*/
- void RenderScene( RenderStatus& status, Integration::Scene& scene, bool renderToFbo );
+ void RenderScene(RenderStatus& status, Integration::Scene& scene, bool renderToFbo);
/**
* Render a scene in the next frame. This method should be preceded by a call up PreRender.
* @param[in] renderToFbo True to render off-screen frame buffers only if any, and False to render the surface only.
* @param[in] clippingRect The rect to clip rendered scene.
*/
- void RenderScene( RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect );
+ void RenderScene(RenderStatus& status, Integration::Scene& scene, bool renderToFbo, Rect<int>& clippingRect);
/**
* This is called after rendering all the scenes in the next frame. This method should be
* @pre The GL context must have been created, and made current.
* @param[in] uploadOnly uploadOnly Upload the resource only without rendering.
*/
- void PostRender( bool uploadOnly );
+ void PostRender(bool uploadOnly);
/**
* @brief Register a processor
* Note, Core does not take ownership of this processor.
* @param[in] processor The process to register
*/
- void RegisterProcessor( Processor& processor );
+ void RegisterProcessor(Processor& processor);
/**
* @brief Unregister a processor
* @param[in] processor The process to unregister
*/
- void UnregisterProcessor( Processor& processor );
+ void UnregisterProcessor(Processor& processor);
/**
* @brief Gets the Object registry.
ObjectRegistry GetObjectRegistry() const;
private:
-
/**
* Private constructor; see also Core::New()
*/
Core& operator=(const Core& rhs);
private:
-
Internal::Core* mImpl;
-
};
} // namespace Integration
#include <dali/integration-api/debug.h>
// EXTERNAL INCLUDES
-#include <cstdio>
#include <cstdarg>
-#include <cstring>
+#include <cstdio>
#include <cstdlib>
-#include <sstream>
-#include <iomanip>
+#include <cstring>
#include <ctime>
+#include <iomanip>
+#include <sstream>
// INTERNAL INCLUDES
+#include <dali/internal/event/common/thread-local-storage.h>
#include <dali/public-api/common/constants.h>
-#include <dali/public-api/math/matrix3.h>
#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/matrix3.h>
+#include <dali/public-api/math/quaternion.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/quaternion.h>
-#include <dali/internal/event/common/thread-local-storage.h>
namespace Dali
{
-
#ifdef DEBUG_ENABLED
// Fake globals for gdb typedefs
#endif
-
namespace // unnamed namespace
{
-
const uint64_t NANOSECONDS_PER_SECOND = 1e+9;
}
namespace Integration
{
-
namespace Log
{
-
thread_local LogFunction gthreadLocalLogFunction = nullptr;
/* Forward declarations */
-std::string FormatToString(const char *format, ...);
-std::string ArgListToString(const char *format, va_list args);
+std::string FormatToString(const char* format, ...);
+std::string ArgListToString(const char* format, va_list args);
void LogMessage(DebugPriority priority, const char* format, ...)
{
- if ( !gthreadLocalLogFunction )
+ if(!gthreadLocalLogFunction)
{
return;
}
std::string message = ArgListToString(format, arg);
va_end(arg);
- gthreadLocalLogFunction(priority,message);
+ gthreadLocalLogFunction(priority, message);
}
void InstallLogFunction(const LogFunction& logFunction)
return activeFilters;
}
-Filter* Filter::New( LogLevel level, bool trace, const char * environmentVariableName )
+Filter* Filter::New(LogLevel level, bool trace, const char* environmentVariableName)
{
- char * environmentVariableValue = getenv( environmentVariableName );
- if ( environmentVariableValue )
+ char* environmentVariableValue = getenv(environmentVariableName);
+ if(environmentVariableValue)
{
unsigned int envLevel(0);
- char envTraceString(0);
- sscanf( environmentVariableValue, "%u,%c", &envLevel, &envTraceString );
+ char envTraceString(0);
+ sscanf(environmentVariableValue, "%u,%c", &envLevel, &envTraceString);
- if ( envLevel > Verbose )
+ if(envLevel > Verbose)
{
envLevel = Verbose;
}
- level = LogLevel( envLevel );
+ level = LogLevel(envLevel);
// Just use 'f' and 't' as it's faster than doing full string comparisons
- if ( envTraceString == 't' )
+ if(envTraceString == 't')
{
trace = true;
}
- else if ( envTraceString == 'f' )
+ else if(envTraceString == 'f')
{
trace = false;
}
}
}
-void Filter::SetGlobalLogLevel( LogLevel level )
+void Filter::SetGlobalLogLevel(LogLevel level)
{
for(FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++)
{
- (*iter)->SetLogLevel( level );
+ (*iter)->SetLogLevel(level);
}
}
va_list arg;
va_start(arg, format);
- if( mTraceEnabled )
+ if(mTraceEnabled)
{
- char *buffer = nullptr;
- int numChars = asprintf( &buffer, " %-*c %s", mNesting, ':', format );
- if( numChars >= 0 ) // No error
+ char* buffer = nullptr;
+ int numChars = asprintf(&buffer, " %-*c %s", mNesting, ':', format);
+ if(numChars >= 0) // No error
{
- std::string message = ArgListToString( buffer, arg );
- LogMessage( DebugInfo, message.c_str() );
- free( buffer );
+ std::string message = ArgListToString(buffer, arg);
+ LogMessage(DebugInfo, message.c_str());
+ free(buffer);
}
}
else
{
- std::string message = ArgListToString( format, arg );
- LogMessage( DebugInfo, message.c_str() );
+ std::string message = ArgListToString(format, arg);
+ LogMessage(DebugInfo, message.c_str());
}
va_end(arg);
}
}
-
-TraceObj::TraceObj(Filter* filter, const char*format, ...) : mFilter(filter)
+TraceObj::TraceObj(Filter* filter, const char* format, ...)
+: mFilter(filter)
{
if(mFilter && mFilter->IsTraceEnabled())
{
{
if(mFilter && mFilter->IsTraceEnabled())
{
- if (mFilter->mNesting)
+ if(mFilter->mNesting)
{
--mFilter->mNesting;
}
#endif // DEBUG_ENABLED
-std::string ArgListToString(const char *format, va_list args)
+std::string ArgListToString(const char* format, va_list args)
{
std::string str; // empty string
- if(format != NULL)
+ if(format != nullptr)
{
- char* buffer = NULL;
- int err = vasprintf(&buffer, format, args);
+ char* buffer = nullptr;
+ int err = vasprintf(&buffer, format, args);
if(err >= 0) // No error
{
str = buffer;
return str;
}
-std::string FormatToString(const char *format, ...)
+std::string FormatToString(const char* format, ...)
{
va_list arg;
va_start(arg, format);
return s;
}
-void GetNanoseconds( uint64_t& timeInNanoseconds )
+void GetNanoseconds(uint64_t& timeInNanoseconds)
{
timespec timeSpec;
- clock_gettime( CLOCK_MONOTONIC, &timeSpec );
+ clock_gettime(CLOCK_MONOTONIC, &timeSpec);
// Convert all values to uint64_t to match our return type
- timeInNanoseconds = ( static_cast< uint64_t >( timeSpec.tv_sec ) * NANOSECONDS_PER_SECOND ) + static_cast< uint64_t >( timeSpec.tv_nsec );
+ timeInNanoseconds = (static_cast<uint64_t>(timeSpec.tv_sec) * NANOSECONDS_PER_SECOND) + static_cast<uint64_t>(timeSpec.tv_nsec);
}
} // namespace Log
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <sstream>
+#include <stdint.h>
#include <iostream>
#include <list>
-#include <stdint.h>
+#include <sstream>
+#include <string>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/object/property-map.h>
#include <dali/public-api/common/dali-common.h>
// Using Debug namespace alias shortens the log usage significantly
-namespace Dali{namespace Integration{namespace Log{}}}
+namespace Dali
+{
+namespace Integration
+{
+namespace Log
+{
+}
+} // namespace Integration
+} // namespace Dali
namespace Debug = Dali::Integration::Log;
namespace Dali
{
-
struct Vector2;
struct Vector3;
struct Vector4;
// Less opaque types for debugger
typedef std::vector<Dali::Property::Value> DebugPropertyValueArray;
-typedef std::pair< Property::Index, Property::Value > DebugIndexValuePair;
-typedef std::vector<Dali::StringValuePair> DebugStringValueContainer;
-typedef std::vector< DebugIndexValuePair > DebugIndexValueContainer;
+using DebugIndexValuePair = std::pair<Property::Index, Property::Value>;
+using DebugStringValueContainer = std::vector<Dali::StringValuePair>;
+using DebugIndexValueContainer = std::vector<DebugIndexValuePair>;
struct DebugPropertyValueMap
{
{
namespace Log
{
-
enum DebugPriority
{
DebugInfo,
* @param level debug level
* @param format string format
*/
-DALI_CORE_API void LogMessage(enum DebugPriority level,const char *format, ...);
+DALI_CORE_API void LogMessage(enum DebugPriority level, const char* format, ...);
/**
* typedef for the logging function.
*/
-typedef void (*LogFunction)(DebugPriority priority, std::string& message);
+using LogFunction = void (*)(DebugPriority, std::string&);
/**
* A log function has to be installed for every thread that wants to use logging.
/**
* Provides unfiltered logging for global error level messages
*/
-#define DALI_LOG_ERROR(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugError, "%s " format, __FUNCTION__, ## __VA_ARGS__)
+#define DALI_LOG_ERROR(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugError, "%s " format, __FUNCTION__, ##__VA_ARGS__)
-#define DALI_LOG_ERROR_NOFN(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugError, format, ## __VA_ARGS__)
+#define DALI_LOG_ERROR_NOFN(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugError, format, ##__VA_ARGS__)
-#define DALI_LOG_WARNING_NOFN(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugWarning, format, ## __VA_ARGS__)
+#define DALI_LOG_WARNING_NOFN(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugWarning, format, ##__VA_ARGS__)
/**
* Provides unfiltered logging for fps monitor
*/
-#define DALI_LOG_FPS(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ## __VA_ARGS__)
+#define DALI_LOG_FPS(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ##__VA_ARGS__)
/**
* Provides unfiltered logging for update status
*/
-#define DALI_LOG_UPDATE_STATUS(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ## __VA_ARGS__)
+#define DALI_LOG_UPDATE_STATUS(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ##__VA_ARGS__)
/**
* Provides unfiltered logging for render information
*/
-#define DALI_LOG_RENDER_INFO(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ## __VA_ARGS__)
+#define DALI_LOG_RENDER_INFO(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ##__VA_ARGS__)
/**
* Provides unfiltered logging for release
*/
-#define DALI_LOG_RELEASE_INFO(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ## __VA_ARGS__)
+#define DALI_LOG_RELEASE_INFO(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugInfo, format, ##__VA_ARGS__)
#ifdef DEBUG_ENABLED
/**
* Provides unfiltered logging for global warning level messages
*/
-#define DALI_LOG_WARNING(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugWarning, "%s " format, ASSERT_LOCATION, ## __VA_ARGS__)
-
+#define DALI_LOG_WARNING(format, ...) Dali::Integration::Log::LogMessage(Dali::Integration::Log::DebugWarning, "%s " format, ASSERT_LOCATION, ##__VA_ARGS__)
#else // DEBUG_ENABLED
*/
enum LogLevel
{
- NoLogging = 0,
- Concise = 1,
- General = 2,
- Verbose = 3
+ NoLogging = 0,
+ Concise = 1,
+ General = 2,
+ Verbose = 3
};
-
/**
* The Filter object is used by the DALI_LOG_INFO macro and others to determine if the logging
* should take place, and routes the logging via the platform abstraction's LogMessage.
class DALI_CORE_API Filter
{
public:
- typedef std::list<Filter*> FilterList;
- typedef std::list<Filter*>::iterator FilterIter;
+ using FilterList = std::list<Filter*>;
+ using FilterIter = std::list<Filter*>::iterator;
public:
-
/**
* Test if the filter is enabled for the given logging level
* @param[in] level - the level to test.
* @return true if this level of logging is enabled.
*/
- bool IsEnabledFor(LogLevel level) { return level != Debug::NoLogging && level <= mLoggingLevel;}
+ bool IsEnabledFor(LogLevel level)
+ {
+ return level != Debug::NoLogging && level <= mLoggingLevel;
+ }
/**
* Test if trace is enabled for this filter.
* @return true if trace is enabled;
*/
- bool IsTraceEnabled() { return mTraceEnabled; }
+ bool IsTraceEnabled()
+ {
+ return mTraceEnabled;
+ }
/**
* Enable tracing on this filter.
*/
- void EnableTrace() { mTraceEnabled = true; }
+ void EnableTrace()
+ {
+ mTraceEnabled = true;
+ }
/**
* Disable tracing on this filter.
*/
- void DisableTrace() { mTraceEnabled = false; }
+ void DisableTrace()
+ {
+ mTraceEnabled = false;
+ }
/**
* Set the log level for this filter. Setting to a higher value than Debug::General also
* enables General;
*/
- void SetLogLevel(LogLevel level) { mLoggingLevel = level; }
+ void SetLogLevel(LogLevel level)
+ {
+ mLoggingLevel = level;
+ }
/**
* Perform the logging for this filter.
* FILTER_ENV=0,true dali-demo // LogLevel NoLogging, Trace ON
* @endcode
*/
- static Filter* New(LogLevel level, bool trace, const char * environmentVariableName );
+ static Filter* New(LogLevel level, bool trace, const char* environmentVariableName);
/**
* Enable trace on all filters.
*
* @param[in] level The log level
*/
- static void SetGlobalLogLevel( LogLevel level );
+ static void SetGlobalLogLevel(LogLevel level);
private:
-
/**
* Constructor.
* @param[in] level - the highest log level.
* @param[in] trace - whether this filter allows tracing.
*/
- Filter(LogLevel level, bool trace) : mLoggingLevel(level), mTraceEnabled(trace), mNesting(0) {}
+ Filter(LogLevel level, bool trace)
+ : mLoggingLevel(level),
+ mTraceEnabled(trace),
+ mNesting(0)
+ {
+ }
static FilterList* GetActiveFilters();
// you can add a filter to your own class or source file. If you do, use Filter::New()
// to tell this class about it.
- static Filter *gRender;
- static Filter *gResource;
- static Filter *gGLResource;
- static Filter *gObject;
- static Filter *gImage;
- static Filter *gModel;
- static Filter *gNode;
- static Filter *gElement;
- static Filter *gActor;
- static Filter *gShader;
+ static Filter* gRender;
+ static Filter* gResource;
+ static Filter* gGLResource;
+ static Filter* gObject;
+ static Filter* gImage;
+ static Filter* gModel;
+ static Filter* gNode;
+ static Filter* gElement;
+ static Filter* gActor;
+ static Filter* gShader;
private:
LogLevel mLoggingLevel;
bool mTraceEnabled;
-public:
- int mNesting;
+public:
+ int mNesting;
};
-
-#define DALI_LOG_FILTER_SET_LEVEL(filter, level) filter->SetLogLevel(level)
-#define DALI_LOG_FILTER_ENABLE_TRACE(filter) filter->EnableTrace()
-#define DALI_LOG_FILTER_DISABLE_TRACE(filter) filter->DisableTrace()
+#define DALI_LOG_FILTER_SET_LEVEL(filter, level) filter->SetLogLevel(level)
+#define DALI_LOG_FILTER_ENABLE_TRACE(filter) filter->EnableTrace()
+#define DALI_LOG_FILTER_DISABLE_TRACE(filter) filter->DisableTrace()
#else
-#define DALI_LOG_FILTER_SET_LEVEL(filter, level)
-#define DALI_LOG_FILTER_ENABLE_TRACE(filter)
-#define DALI_LOG_FILTER_DISABLE_TRACE(filter)
+#define DALI_LOG_FILTER_SET_LEVEL(filter, level)
+#define DALI_LOG_FILTER_ENABLE_TRACE(filter)
+#define DALI_LOG_FILTER_DISABLE_TRACE(filter)
#endif
#ifdef DEBUG_ENABLED
-#define DALI_LOG_INFO(filter, level, format, ...) \
- if(filter && filter->IsEnabledFor(level)) { filter->Log(level, format, ## __VA_ARGS__); }
-
-#define DALI_LOG_STREAM( filter, level, stream ) \
+#define DALI_LOG_INFO(filter, level, format, ...) \
if(filter && filter->IsEnabledFor(level)) \
{ \
- std::ostringstream o; \
- o << stream << std::endl; \
- filter->Log(level, "%s", o.str().c_str()); \
+ filter->Log(level, format, ##__VA_ARGS__); \
+ }
+
+#define DALI_LOG_STREAM(filter, level, stream) \
+ if(filter && filter->IsEnabledFor(level)) \
+ { \
+ std::ostringstream o; \
+ o << stream << std::endl; \
+ filter->Log(level, "%s", o.str().c_str()); \
}
#else // DEBUG_ENABLED
#define DALI_LOG_INFO(filter, level, format, ...)
-#define DALI_LOG_STREAM( filter, level, stream )
+#define DALI_LOG_STREAM(filter, level, stream)
#endif // DEBUG_ENABLED
-
/********************************************************************************
* Trace Macros *
********************************************************************************/
public:
std::string mMessage;
- Filter* mFilter;
+ Filter* mFilter;
};
+#define DALI_LOG_TRACE_METHOD_FMT(filter, format, ...) \
+ Dali::Integration::Log::TraceObj debugTraceObj(filter, "%s: " format, ASSERT_LOCATION, ##__VA_ARGS__)
-#define DALI_LOG_TRACE_METHOD_FMT(filter, format, ...) \
- Dali::Integration::Log::TraceObj debugTraceObj(filter, "%s: " format, ASSERT_LOCATION, ## __VA_ARGS__)
-
-#define DALI_LOG_TRACE_METHOD(filter) \
+#define DALI_LOG_TRACE_METHOD(filter) \
Dali::Integration::Log::TraceObj debugTraceObj(filter, ASSERT_LOCATION)
-
#else // DEBUG_ENABLED
#define DALI_LOG_TRACE_METHOD_FMT(filter, format, ...)
#define DALI_LOG_TRACE_METHOD(filter)
-
#endif
/********************************************************************************
* Warning - this will increase the size of the object for a debug build.
*/
#define DALI_LOG_OBJECT_STRING_DECLARATION \
-public: \
+public: \
std::string mDebugString;
/**
* Print all the actor tree names
**/
-#define DALI_LOG_ACTOR_TREE( node ) { \
- std::stringstream branch; \
- Node* tempNode = node; \
- while( tempNode ) { \
- branch << "<" << tempNode->mDebugString << ">::"; \
- tempNode = tempNode->GetParent(); \
- } \
- DALI_LOG_ERROR_NOFN("Actor tree: %s\n", branch.str().c_str()); \
-}
+#define DALI_LOG_ACTOR_TREE(node) \
+ { \
+ std::stringstream branch; \
+ Node* tempNode = node; \
+ while(tempNode) \
+ { \
+ branch << "<" << tempNode->mDebugString << ">::"; \
+ tempNode = tempNode->GetParent(); \
+ } \
+ DALI_LOG_ERROR_NOFN("Actor tree: %s\n", branch.str().c_str()); \
+ }
/**
* Allows one object to set another object's debug string
/**
* Allows one object to set another object's std::string easily
*/
-#define DALI_LOG_FMT_OBJECT_STRING(object, fmt, ...) (object->mDebugString = FormatToString(fmt, ## __VA_ARGS__))
+#define DALI_LOG_FMT_OBJECT_STRING(object, fmt, ...) (object->mDebugString = FormatToString(fmt, ##__VA_ARGS__))
/**
* Allows one object to get another object's debug string
/**
* Filtered logging of the object's debug string
*/
-#define DALI_LOG_OBJECT(filter, object) DALI_LOG_INFO(filter, Debug::General, object->mDebugString)
-
+#define DALI_LOG_OBJECT(filter, object) DALI_LOG_INFO(filter, Debug::General, object->mDebugString)
#else // DEBUG_ENABLED
#if defined(DEBUG_ENABLED)
-void GetNanoseconds( uint64_t& timeInNanoseconds );
+void GetNanoseconds(uint64_t& timeInNanoseconds);
-#define DALI_LOG_TIMER_START( timeVariable ) \
- uint64_t timeVariable##1; \
- Debug::GetNanoseconds( timeVariable##1 );
+#define DALI_LOG_TIMER_START(timeVariable) \
+ uint64_t timeVariable##1; \
+ Debug::GetNanoseconds(timeVariable##1);
-#define DALI_LOG_TIMER_END( timeVariable, filter, level, preString) \
- uint64_t timeVariable##2; \
- Debug::GetNanoseconds( timeVariable##2 ); \
- DALI_LOG_INFO( filter, level, preString " %ld uSec\n", ((timeVariable##2-timeVariable##1)/1000));
+#define DALI_LOG_TIMER_END(timeVariable, filter, level, preString) \
+ uint64_t timeVariable##2; \
+ Debug::GetNanoseconds(timeVariable##2); \
+ DALI_LOG_INFO(filter, level, preString " %ld uSec\n", ((timeVariable##2 - timeVariable##1) / 1000));
#else // DEBUG_ENABLED
-#define DALI_LOG_TIMER_START( timeVariable )
-#define DALI_LOG_TIMER_END( timeVariable, filter, level, preString)
+#define DALI_LOG_TIMER_START(timeVariable)
+#define DALI_LOG_TIMER_END(timeVariable, filter, level, preString)
#endif
-} // Debug
-} // Integration
-} // Dali
-
+} // namespace Log
+} // namespace Integration
+} // namespace Dali
#endif // DALI_INTEGRATION_DEBUG_H
namespace Dali
{
-
namespace Integration
{
-
Event::~Event()
{
}
#define DALI_INTEGRATION_EVENT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
/**
* Base structure for events passed to Dali::Integration::Core::QueueEvent()
* An instance of this class cannot be created.
enum Type
{
- Touch, ///< A touch event, when the user interacts with the screen.
- Key, ///< A key pressed event, from the virtual or external keyboard.
- Wheel, ///< A wheel event, when the wheel is being rolled from an external mouse.
- Hover ///< A hover event, when the user hovers above the screen.
+ Touch, ///< A touch event, when the user interacts with the screen.
+ Key, ///< A key pressed event, from the virtual or external keyboard.
+ Wheel, ///< A wheel event, when the wheel is being rolled from an external mouse.
+ Hover ///< A hover event, when the user hovers above the screen.
};
// Data
Type type;
protected: // Constructors only to be used by derived structures.
-
/**
* This constructor is only used by derived classes.
* @param[in] eventType The type of event.
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
HoverEvent::HoverEvent()
-: MultiPointEvent( Hover )
+: MultiPointEvent(Hover)
{
}
-HoverEvent::HoverEvent( uint32_t time )
-: MultiPointEvent( Hover, time )
+HoverEvent::HoverEvent(uint32_t time)
+: MultiPointEvent(Hover, time)
{
}
#define DALI_INTEGRATION_HOVER_EVENT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/events/hover-event.h>
#include <dali/integration-api/events/multi-point-event-integ.h>
+#include <dali/public-api/events/hover-event.h>
namespace Dali
{
-
namespace Integration
{
-
/**
* An instance of this structure should be used by the adaptor to send a hover event to Dali core.
*
/**
* Virtual destructor
*/
- virtual ~HoverEvent();
+ ~HoverEvent() override;
};
} // namespace Integration
namespace Dali
{
-
namespace Integration
{
-
KeyEvent::KeyEvent()
-: Event( Key ),
+: Event(Key),
keyName(),
logicalKey(),
keyString(),
- keyCode( -1 ),
- keyModifier( 0 ),
- time( 0 ),
- state( KeyEvent::DOWN ),
- compose( "" ),
- deviceName( "" ),
- deviceClass( Device::Class::NONE ),
- deviceSubclass( Device::Subclass::NONE )
+ keyCode(-1),
+ keyModifier(0),
+ time(0),
+ state(KeyEvent::DOWN),
+ compose(""),
+ deviceName(""),
+ deviceClass(Device::Class::NONE),
+ deviceSubclass(Device::Subclass::NONE)
{
}
-KeyEvent::KeyEvent( const std::string& keyName, const std::string& logicalKey, const std::string& keyString, int keyCode, int keyModifier,
- unsigned long timeStamp, const State& keyState, const std::string& compose, const std::string& deviceName,
- const Device::Class::Type deviceClass, const Device::Subclass::Type deviceSubclass )
-: Event( Key ),
- keyName( keyName ),
- logicalKey( logicalKey ),
- keyString( keyString ),
- keyCode( keyCode ),
- keyModifier( keyModifier ),
- time( timeStamp ),
- state( keyState ),
- compose( compose ),
- deviceName( deviceName ),
- deviceClass( deviceClass ),
- deviceSubclass( deviceSubclass )
+KeyEvent::KeyEvent(const std::string& keyName,
+ const std::string& logicalKey,
+ const std::string& keyString,
+ int keyCode,
+ int keyModifier,
+ unsigned long timeStamp,
+ const State& keyState,
+ const std::string& compose,
+ const std::string& deviceName,
+ const Device::Class::Type deviceClass,
+ const Device::Subclass::Type deviceSubclass)
+: Event(Key),
+ keyName(keyName),
+ logicalKey(logicalKey),
+ keyString(keyString),
+ keyCode(keyCode),
+ keyModifier(keyModifier),
+ time(timeStamp),
+ state(keyState),
+ compose(compose),
+ deviceName(deviceName),
+ deviceClass(deviceClass),
+ deviceSubclass(deviceSubclass)
{
}
namespace Dali
{
-
namespace Integration
{
-
/**
* An instance of this class should be used by the adaptor to send a key event to
* the Dali core.
// Specifies the state of the key event.
enum State
{
- DOWN, /**< Key down */
- UP, /**< Key up */
+ DOWN, /**< Key down */
+ UP, /**< Key up */
};
/**
* @param[in] deviceClass The class of device KeyEvent originated from
* @param[in] deviceSubclass The subclass of device KeyEvent originated from
*/
- KeyEvent(const std::string& keyName,
- const std::string& logicalKey,
- const std::string& keyString,
- int keyCode,
- int keyModifier,
- unsigned long timeStamp,
- const State& keyState,
- const std::string& compose,
- const std::string& deviceName,
- const Device::Class::Type deviceClass,
- const Device::Subclass::Type deviceSubclass );
+ KeyEvent(const std::string& keyName,
+ const std::string& logicalKey,
+ const std::string& keyString,
+ int keyCode,
+ int keyModifier,
+ unsigned long timeStamp,
+ const State& keyState,
+ const std::string& compose,
+ const std::string& deviceName,
+ const Device::Class::Type deviceClass,
+ const Device::Subclass::Type deviceSubclass);
/**
* Virtual destructor
*/
- virtual ~KeyEvent();
+ ~KeyEvent() override;
// Data
/**
* The unique key code for the key pressed.
*/
- int keyCode;
+ int keyCode;
/**
* The key modifier for special keys like shift and alt
*/
- int keyModifier;
+ int keyModifier;
/**
* The time (in ms) that the key event occurred.
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
-MultiPointEvent::MultiPointEvent( Type eventType )
-: Event( eventType ),
- time( 0 )
+MultiPointEvent::MultiPointEvent(Type eventType)
+: Event(eventType),
+ time(0)
{
}
-MultiPointEvent::MultiPointEvent( Type eventType, uint32_t time )
-: Event( eventType ),
- time( time )
+MultiPointEvent::MultiPointEvent(Type eventType, uint32_t time)
+: Event(eventType),
+ time(time)
{
}
{
}
-void MultiPointEvent::AddPoint( const Point& point )
+void MultiPointEvent::AddPoint(const Point& point)
{
points.push_back(point);
}
-Point& MultiPointEvent::GetPoint( uint32_t point )
+Point& MultiPointEvent::GetPoint(uint32_t point)
{
DALI_ASSERT_ALWAYS(point < points.size() && "MultiPointEvent: Point index out of bounds");
return points[point];
}
-const Point& MultiPointEvent::GetPoint( uint32_t point ) const
+const Point& MultiPointEvent::GetPoint(uint32_t point) const
{
DALI_ASSERT_ALWAYS(point < points.size() && "MultiPointEvent: Point index out of bounds");
return points[point];
uint32_t MultiPointEvent::GetPointCount() const
{
- return static_cast<uint32_t>( points.size() ); // not going to overflow in practice
+ return static_cast<uint32_t>(points.size()); // not going to overflow in practice
}
} // namespace Integration
#define DALI_INTEGRATION_MULTI_POINT_EVENT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/common/vector-wrapper.h>
#include <dali/integration-api/events/event.h>
#include <dali/integration-api/events/point.h>
+#include <dali/public-api/common/vector-wrapper.h>
namespace Dali
{
-
namespace Integration
{
-
-typedef std::vector< Point > PointContainer; ///< Container of points
-typedef PointContainer::iterator PointContainerIterator; ///< Iterator for Dali::Integration::PointContainer
-typedef PointContainer::const_iterator PointContainerConstIterator; ///< Const iterator for Dali::Integration::PointContainer
+using PointContainer = std::vector<Point>; ///< Container of points
+using PointContainerIterator = PointContainer::iterator; ///< Iterator for Dali::Integration::PointContainer
+using PointContainerConstIterator = PointContainer::const_iterator; ///< Const iterator for Dali::Integration::PointContainer
/**
* An instance of this structure should be used by the adaptor to send a multi-point event to Dali core.
/**
* Virtual destructor
*/
- virtual ~MultiPointEvent();
+ ~MultiPointEvent() override;
protected:
/**
MultiPointEvent(Type eventType, uint32_t time);
public:
-
// Data
/**
* @brief Adds a point to the MultiPointEvent.
* @param[in] point The point to add.
*/
- void AddPoint( const Point& point );
+ void AddPoint(const Point& point);
/**
* @brief Retrieves the Point at position point.
* @return The Point at position point.
*/
- Point& GetPoint( uint32_t point );
+ Point& GetPoint(uint32_t point);
/**
* @brief Retrieves a const ref of the Point at position point.
* @return The const ref of the Point at position point.
*/
- const Point& GetPoint( uint32_t point ) const;
+ const Point& GetPoint(uint32_t point) const;
/**
* @brief The total number of Points in this TouchEvent.
namespace Dali
{
-
namespace Integration
{
-
Point::Point()
-: mTouchPoint( 0, PointState::STARTED, 0.0f, 0.0f ),
+: mTouchPoint(0, PointState::STARTED, 0.0f, 0.0f),
mEllipseRadius(),
- mAngle( 0.0f ),
- mDeviceClass( Device::Class::NONE ),
- mDeviceSubclass( Device::Subclass::NONE ),
- mPressure( 1.0f ),
- mRadius( 0.0f ),
- mMouseButton( MouseButton::INVALID )
+ mAngle(0.0f),
+ mDeviceClass(Device::Class::NONE),
+ mDeviceSubclass(Device::Subclass::NONE),
+ mPressure(1.0f),
+ mRadius(0.0f),
+ mMouseButton(MouseButton::INVALID)
{
}
-Point::Point( const TouchPoint& touchPoint )
-: mTouchPoint( touchPoint ),
+Point::Point(const TouchPoint& touchPoint)
+: mTouchPoint(touchPoint),
mEllipseRadius(),
- mAngle( 0.0f ),
- mDeviceClass( Device::Class::NONE ),
- mDeviceSubclass( Device::Subclass::NONE ),
- mPressure( 1.0f ),
- mRadius( 0.0f ),
- mMouseButton( MouseButton::INVALID )
+ mAngle(0.0f),
+ mDeviceClass(Device::Class::NONE),
+ mDeviceSubclass(Device::Subclass::NONE),
+ mPressure(1.0f),
+ mRadius(0.0f),
+ mMouseButton(MouseButton::INVALID)
{
}
{
}
-void Point::SetDeviceId( int32_t deviceId )
+void Point::SetDeviceId(int32_t deviceId)
{
mTouchPoint.deviceId = deviceId;
}
-void Point::SetState( PointState::Type state )
+void Point::SetState(PointState::Type state)
{
- mTouchPoint.state = static_cast< PointState::Type >( state );
+ mTouchPoint.state = static_cast<PointState::Type>(state);
}
-void Point::SetScreenPosition( const Vector2& screenPosition )
+void Point::SetScreenPosition(const Vector2& screenPosition)
{
mTouchPoint.screen = screenPosition;
}
-void Point::SetRadius( float radius )
+void Point::SetRadius(float radius)
{
mRadius = mEllipseRadius.x = mEllipseRadius.y = radius;
}
-void Point::SetRadius( float radius, Vector2 ellipseRadius )
+void Point::SetRadius(float radius, Vector2 ellipseRadius)
{
- mRadius = radius;
+ mRadius = radius;
mEllipseRadius = ellipseRadius;
}
-void Point::SetPressure( float pressure )
+void Point::SetPressure(float pressure)
{
mPressure = pressure;
}
-void Point::SetAngle( Degree angle )
+void Point::SetAngle(Degree angle)
{
mAngle = angle;
}
PointState::Type Point::GetState() const
{
- return static_cast< PointState::Type >( mTouchPoint.state );
+ return static_cast<PointState::Type>(mTouchPoint.state);
}
const Vector2& Point::GetScreenPosition() const
return mAngle;
}
-void Point::SetHitActor( Actor hitActor )
+void Point::SetHitActor(Actor hitActor)
{
mTouchPoint.hitActor = hitActor;
}
-void Point::SetLocalPosition( const Vector2& localPosition )
+void Point::SetLocalPosition(const Vector2& localPosition)
{
mTouchPoint.local = localPosition;
}
return mTouchPoint;
}
-void Point::SetDeviceClass( Device::Class::Type deviceClass )
+void Point::SetDeviceClass(Device::Class::Type deviceClass)
{
mDeviceClass = deviceClass;
}
-void Point::SetDeviceSubclass( Device::Subclass::Type deviceSubclass )
+void Point::SetDeviceSubclass(Device::Subclass::Type deviceSubclass)
{
mDeviceSubclass = deviceSubclass;
}
mMouseButton = button;
}
-
} // namespace Integration
} // namespace Dali
*/
// INTERNAL INCLUDES
-#include <dali/public-api/events/point-state.h>
-#include <dali/public-api/math/degree.h>
-#include <dali/public-api/math/vector2.h>
#include <dali/devel-api/events/touch-point.h>
#include <dali/public-api/events/device.h>
#include <dali/public-api/events/mouse-button.h>
+#include <dali/public-api/events/point-state.h>
+#include <dali/public-api/math/degree.h>
+#include <dali/public-api/math/vector2.h>
namespace Dali
{
-
namespace Integration
{
-
/**
* @brief A Point represents a point on the screen that is currently being touched or where touch has stopped.
*/
* @brief Constructor which creates a Point instance from a TouchPoint.
* @param[in] touchPoint The touch-point to copy from.
*/
- explicit Point( const TouchPoint& touchPoint );
+ explicit Point(const TouchPoint& touchPoint);
/**
* @brief Destructor
*
* @param[in] deviceId The Unique Device ID.
*/
- void SetDeviceId( int32_t deviceId );
+ void SetDeviceId(int32_t deviceId);
/**
* @brief Set the state of the point.
* @param[in] state The state of the point.
*/
- void SetState( PointState::Type state );
+ void SetState(PointState::Type state);
/**
* @brief Set the screen position of the point from the top-left of the screen.
* @param[in] screenPosition The screen position of the point from the top-left of the screen.
*/
- void SetScreenPosition( const Vector2& screenPosition );
+ void SetScreenPosition(const Vector2& screenPosition);
/**
* @brief Set the radius of the press point.
* This is the average of both the horizontal and vertical radii of the press point.
* @param[in] radius The average of both the horizontal and vertical radii.
*/
- void SetRadius( float radius );
+ void SetRadius(float radius);
/**
* @brief Set the radius of the press point as an ellipse.
* @param[in] radius The average of both the horizontal and vertical radii.
* @param[in] ellipseRadius The horizontal and vertical radii of the press point (different if an ellipse).
*/
- void SetRadius( float radius, Vector2 ellipseRadius );
+ void SetRadius(float radius, Vector2 ellipseRadius);
/**
* @brief Sets the touch pressure.
*
* @param[in] pressure The touch pressure.
*/
- void SetPressure( float pressure );
+ void SetPressure(float pressure);
/**
* @brief Sets the angle of the press point relative to the Y-Axis.
* @param[in] angle The angle of the press point relative to the Y-Axis.
*/
- void SetAngle( Degree angle );
+ void SetAngle(Degree angle);
/**
* @brief Sets the class of the device for the event
* @param[in] deviceClass The class of the device.
*/
- void SetDeviceClass( Device::Class::Type deviceClass );
+ void SetDeviceClass(Device::Class::Type deviceClass);
/**
* @brief Sets the subclass of the device for the event
* @param[in] deviceSubclass The subclass of the device.
*/
- void SetDeviceSubclass( Device::Subclass::Type deviceSubclass );
+ void SetDeviceSubclass(Device::Subclass::Type deviceSubclass);
/**
* @brief Retrieve the Unique Device ID of the point.
*/
void SetMouseButton(MouseButton::Type button);
-
public: // Not intended for Integration API developers
-
/**
* @brief Sets the hit actor under this point.
* @param[in] hitActor The hit actor.
*/
- DALI_INTERNAL void SetHitActor( Actor hitActor );
+ DALI_INTERNAL void SetHitActor(Actor hitActor);
/**
* @brief Set the co-ordinates relative to the top-left of the hit-actor.
* @param[in] localPosition The local position.
* @note The top-left of an actor is (0.0, 0.0, 0.5).
*/
- DALI_INTERNAL void SetLocalPosition( const Vector2& localPosition );
+ DALI_INTERNAL void SetLocalPosition(const Vector2& localPosition);
/**
* @brief Retrieve the Hit Actor.
DALI_INTERNAL const TouchPoint& GetTouchPoint() const;
private:
-
- TouchPoint mTouchPoint; ///< Stores screen position, device Id, local & screen positions and the hit-actor. @see TouchPoint
- Vector2 mEllipseRadius; ///< Radius of both the horizontal and vertical radius (useful if an ellipse).
- Degree mAngle; ///< The angle of the press point, relative to the Y-Axis.
- Device::Class::Type mDeviceClass;
+ TouchPoint mTouchPoint; ///< Stores screen position, device Id, local & screen positions and the hit-actor. @see TouchPoint
+ Vector2 mEllipseRadius; ///< Radius of both the horizontal and vertical radius (useful if an ellipse).
+ Degree mAngle; ///< The angle of the press point, relative to the Y-Axis.
+ Device::Class::Type mDeviceClass;
Device::Subclass::Type mDeviceSubclass;
- float mPressure; ///< The touch pressure.
- float mRadius; ///< Radius of the press point, an average of the ellipse radius.
- MouseButton::Type mMouseButton; /// < mouse button value.
+ float mPressure; ///< The touch pressure.
+ float mRadius; ///< Radius of the press point, an average of the ellipse radius.
+ MouseButton::Type mMouseButton; /// < mouse button value.
};
} // namespace Integration
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <cmath> // abs<float>
// INTERNAL INCLUDES
-#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/integration-api/events/hover-event-integ.h>
+#include <dali/integration-api/events/touch-event-integ.h>
#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
namespace Integration
{
-
namespace
{
-const unsigned long DEFAULT_MINIMUM_MOTION_TIME( 1u );
-const Vector2 DEFAULT_MINIMUM_MOTION_DISTANCE( 1.0f, 1.0f );
+const unsigned long DEFAULT_MINIMUM_MOTION_TIME(1u);
+const Vector2 DEFAULT_MINIMUM_MOTION_DISTANCE(1.0f, 1.0f);
} // unnamed namespace
struct TouchEventCombiner::PointInfo
* @param[in] touchPoint The point to add.
* @param[in] pointTime The time of the point event.
*/
- PointInfo( const Point& touchPoint, uint32_t pointTime )
- : point( touchPoint ),
- time( pointTime )
+ PointInfo(const Point& touchPoint, uint32_t pointTime)
+ : point(touchPoint),
+ time(pointTime)
{
}
// Data
- Point point; ///< The point.
- uint32_t time; ///< The time the point event took place.
+ Point point; ///< The point.
+ uint32_t time; ///< The time the point event took place.
};
TouchEventCombiner::TouchEventCombiner()
-: mMinMotionTime( DEFAULT_MINIMUM_MOTION_TIME ),
- mMinMotionDistance( DEFAULT_MINIMUM_MOTION_DISTANCE )
+: mMinMotionTime(DEFAULT_MINIMUM_MOTION_TIME),
+ mMinMotionDistance(DEFAULT_MINIMUM_MOTION_DISTANCE)
{
}
-TouchEventCombiner::TouchEventCombiner( uint32_t minMotionTime, float minMotionXDistance, float minMotionYDistance )
-: mMinMotionTime( minMotionTime ),
- mMinMotionDistance( minMotionXDistance, minMotionYDistance )
+TouchEventCombiner::TouchEventCombiner(uint32_t minMotionTime, float minMotionXDistance, float minMotionYDistance)
+: mMinMotionTime(minMotionTime),
+ mMinMotionDistance(minMotionXDistance, minMotionYDistance)
{
- DALI_ASSERT_ALWAYS( minMotionXDistance >= 0.0f && minMotionYDistance >= 0.0f && "Negative values not allowed\n" );
+ DALI_ASSERT_ALWAYS(minMotionXDistance >= 0.0f && minMotionYDistance >= 0.0f && "Negative values not allowed\n");
}
-TouchEventCombiner::TouchEventCombiner( uint32_t minMotionTime, Vector2 minMotionDistance )
-: mMinMotionTime( minMotionTime ),
- mMinMotionDistance( minMotionDistance )
+TouchEventCombiner::TouchEventCombiner(uint32_t minMotionTime, Vector2 minMotionDistance)
+: mMinMotionTime(minMotionTime),
+ mMinMotionDistance(minMotionDistance)
{
- DALI_ASSERT_ALWAYS( minMotionDistance.x >= 0.0f && minMotionDistance.y >= 0.0f && "Negative values not allowed\n" );
+ DALI_ASSERT_ALWAYS(minMotionDistance.x >= 0.0f && minMotionDistance.y >= 0.0f && "Negative values not allowed\n");
}
TouchEventCombiner::~TouchEventCombiner()
{
}
-TouchEventCombiner::EventDispatchType TouchEventCombiner::GetNextTouchEvent( const Point& point, uint32_t time, TouchEvent& touchEvent, HoverEvent& hoverEvent )
+TouchEventCombiner::EventDispatchType TouchEventCombiner::GetNextTouchEvent(const Point& point, uint32_t time, TouchEvent& touchEvent, HoverEvent& hoverEvent)
{
- TouchEventCombiner::EventDispatchType dispatchEvent( TouchEventCombiner::DISPATCH_NONE );
- const PointState::Type state = point.GetState();
- const int deviceId = point.GetDeviceId();
+ TouchEventCombiner::EventDispatchType dispatchEvent(TouchEventCombiner::DISPATCH_NONE);
+ const PointState::Type state = point.GetState();
+ const int deviceId = point.GetDeviceId();
- switch ( state )
+ switch(state)
{
case PointState::STARTED:
{
touchEvent.time = time;
- bool addToContainer( true );
+ bool addToContainer(true);
// Iterate through already stored touch points and add to TouchEvent
- for ( PointInfoContainer::iterator iter = mPressedPoints.begin(), endIter = mPressedPoints.end(); iter != endIter; ++iter )
+ for(PointInfoContainer::iterator iter = mPressedPoints.begin(), endIter = mPressedPoints.end(); iter != endIter; ++iter)
{
- if ( iter->point.GetDeviceId() != deviceId )
+ if(iter->point.GetDeviceId() != deviceId)
{
- iter->point.SetState( PointState::STATIONARY );
+ iter->point.SetState(PointState::STATIONARY);
}
else
{
// We do not want to emit another down event for this Point Device ID.
addToContainer = false;
- iter->point = point;
- iter->time = time;
+ iter->point = point;
+ iter->time = time;
}
- touchEvent.AddPoint( iter->point );
+ touchEvent.AddPoint(iter->point);
}
// Add new touch point to the list and to the TouchEvent
- if (addToContainer)
+ if(addToContainer)
{
- mPressedPoints.push_back( PointInfo( point, time ) );
- touchEvent.AddPoint( point );
+ mPressedPoints.push_back(PointInfo(point, time));
+ touchEvent.AddPoint(point);
dispatchEvent = TouchEventCombiner::DISPATCH_TOUCH; // Only dispatch touch event if just added to container
// Check whether hover event was dispatched previously
- if ( !mHoveredPoints.empty() )
+ if(!mHoveredPoints.empty())
{
hoverEvent.time = time;
- PointInfoContainer::iterator match( mHoveredPoints.end() );
- for ( PointInfoContainer::iterator iter = mHoveredPoints.begin(), endIter = mHoveredPoints.end(); iter != endIter; ++iter )
+ PointInfoContainer::iterator match(mHoveredPoints.end());
+ for(PointInfoContainer::iterator iter = mHoveredPoints.begin(), endIter = mHoveredPoints.end(); iter != endIter; ++iter)
{
- if ( deviceId == iter->point.GetDeviceId() )
+ if(deviceId == iter->point.GetDeviceId())
{
match = iter;
// Add new point to the HoverEvent
- iter->point.SetState( PointState::FINISHED );
- hoverEvent.AddPoint( iter->point );
+ iter->point.SetState(PointState::FINISHED);
+ hoverEvent.AddPoint(iter->point);
}
else
{
- iter->point.SetState( PointState::STATIONARY );
- hoverEvent.AddPoint( iter->point );
+ iter->point.SetState(PointState::STATIONARY);
+ hoverEvent.AddPoint(iter->point);
}
}
- if ( match != mHoveredPoints.end() )
+ if(match != mHoveredPoints.end())
{
- mHoveredPoints.erase( match );
+ mHoveredPoints.erase(match);
dispatchEvent = TouchEventCombiner::DISPATCH_BOTH; // We should only dispatch hover events if the point was actually hovered in this window
}
}
touchEvent.time = time;
// Find pressed touch point in local list (while also adding the stored points to the touchEvent)
- PointInfoContainer::iterator match( mPressedPoints.end() );
- for ( PointInfoContainer::iterator iter = mPressedPoints.begin(), endIter = mPressedPoints.end(); iter != endIter; ++iter )
+ PointInfoContainer::iterator match(mPressedPoints.end());
+ for(PointInfoContainer::iterator iter = mPressedPoints.begin(), endIter = mPressedPoints.end(); iter != endIter; ++iter)
{
- if ( deviceId == iter->point.GetDeviceId() )
+ if(deviceId == iter->point.GetDeviceId())
{
match = iter;
// Add new point to the TouchEvent
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
}
else
{
- iter->point.SetState( PointState::STATIONARY );
- touchEvent.AddPoint( iter->point );
+ iter->point.SetState(PointState::STATIONARY);
+ touchEvent.AddPoint(iter->point);
}
}
- if ( match != mPressedPoints.end() )
+ if(match != mPressedPoints.end())
{
- mPressedPoints.erase( match );
+ mPressedPoints.erase(match);
dispatchEvent = TouchEventCombiner::DISPATCH_TOUCH; // We should only dispatch touch events if the point was actually pressed in this window
// Iterate through already stored touch points for HoverEvent and delete them
- for ( PointInfoContainer::iterator iter = mHoveredPoints.begin(), endIter = mHoveredPoints.end(); iter != endIter; ++iter )
+ for(PointInfoContainer::iterator iter = mHoveredPoints.begin(), endIter = mHoveredPoints.end(); iter != endIter; ++iter)
{
- if ( iter->point.GetDeviceId() == deviceId )
+ if(iter->point.GetDeviceId() == deviceId)
{
- iter = mHoveredPoints.erase( iter );
+ iter = mHoveredPoints.erase(iter);
}
}
}
{
bool fromNewDeviceId = false;
- if ( !mPressedPoints.empty() )
+ if(!mPressedPoints.empty())
{
touchEvent.time = time;
- bool ignore = false;
- PointInfoContainer::iterator match = mPressedPoints.end();
- const Vector2& pointScreenPosition = point.GetScreenPosition();
- for ( PointInfoContainer::iterator iter = mPressedPoints.begin(), endIter = mPressedPoints.end(); iter != endIter; ++iter )
+ bool ignore = false;
+ PointInfoContainer::iterator match = mPressedPoints.end();
+ const Vector2& pointScreenPosition = point.GetScreenPosition();
+ for(PointInfoContainer::iterator iter = mPressedPoints.begin(), endIter = mPressedPoints.end(); iter != endIter; ++iter)
{
- if ( deviceId == iter->point.GetDeviceId() )
+ if(deviceId == iter->point.GetDeviceId())
{
- uint32_t timeDiff( time - iter->time );
+ uint32_t timeDiff(time - iter->time);
- if ( timeDiff < mMinMotionTime )
+ if(timeDiff < mMinMotionTime)
{
// Motion event sent too soon after previous event so ignore
ignore = true;
}
const Vector2& currentScreenPosition = iter->point.GetScreenPosition();
- if ( ( std::abs( pointScreenPosition.x - currentScreenPosition.x ) < mMinMotionDistance.x ) &&
- ( std::abs( pointScreenPosition.y - currentScreenPosition.y ) < mMinMotionDistance.y ) )
+ if((std::abs(pointScreenPosition.x - currentScreenPosition.x) < mMinMotionDistance.x) &&
+ (std::abs(pointScreenPosition.y - currentScreenPosition.y) < mMinMotionDistance.y))
{
// Not enough positional change from last event so ignore
ignore = true;
match = iter;
// Add new touch point to the TouchEvent
- touchEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
}
else
{
- iter->point.SetState( PointState::STATIONARY );
- touchEvent.AddPoint( iter->point );
+ iter->point.SetState(PointState::STATIONARY);
+ touchEvent.AddPoint(iter->point);
}
}
- if ( match != mPressedPoints.end() )
+ if(match != mPressedPoints.end())
{
- PointInfo matchedPoint( point, time );
- std::swap( *match, matchedPoint );
+ PointInfo matchedPoint(point, time);
+ std::swap(*match, matchedPoint);
dispatchEvent = TouchEventCombiner::DISPATCH_TOUCH; // Dispatch touch event
}
hoverEvent.time = time;
// Iterate through already stored touch points and add to HoverEvent
- bool ignore = false;
- PointInfoContainer::iterator match = mHoveredPoints.end();
- const Vector2& pointScreenPosition = point.GetScreenPosition();
- for ( PointInfoContainer::iterator iter = mHoveredPoints.begin(), endIter = mHoveredPoints.end(); iter != endIter; ++iter )
+ bool ignore = false;
+ PointInfoContainer::iterator match = mHoveredPoints.end();
+ const Vector2& pointScreenPosition = point.GetScreenPosition();
+ for(PointInfoContainer::iterator iter = mHoveredPoints.begin(), endIter = mHoveredPoints.end(); iter != endIter; ++iter)
{
- if ( iter->point.GetDeviceId() == deviceId )
+ if(iter->point.GetDeviceId() == deviceId)
{
- uint32_t timeDiff( time - iter->time );
+ uint32_t timeDiff(time - iter->time);
- if ( timeDiff < mMinMotionTime )
+ if(timeDiff < mMinMotionTime)
{
// Motion event sent too soon after previous event so ignore
ignore = true;
}
const Vector2& currentScreenPosition = iter->point.GetScreenPosition();
- if ( ( std::abs( pointScreenPosition.x - currentScreenPosition.x ) < mMinMotionDistance.x ) &&
- ( std::abs( pointScreenPosition.y - currentScreenPosition.y ) < mMinMotionDistance.y ) )
+ if((std::abs(pointScreenPosition.x - currentScreenPosition.x) < mMinMotionDistance.x) &&
+ (std::abs(pointScreenPosition.y - currentScreenPosition.y) < mMinMotionDistance.y))
{
// Not enough positional change from last event so ignore
ignore = true;
match = iter;
// Add new touch point to the HoverEvent
- hoverEvent.AddPoint( point );
+ hoverEvent.AddPoint(point);
}
else
{
- iter->point.SetState( PointState::STATIONARY );
- hoverEvent.AddPoint( iter->point );
+ iter->point.SetState(PointState::STATIONARY);
+ hoverEvent.AddPoint(iter->point);
}
}
// Add new hover point to the list and to the HoverEvent
- if ( !ignore ) // Only dispatch hover event when it should not be ignored
+ if(!ignore) // Only dispatch hover event when it should not be ignored
{
- if( match == mHoveredPoints.end() )
+ if(match == mHoveredPoints.end())
{
Point hoverPoint(point);
- hoverPoint.SetState( PointState::STARTED ); // The first hover event received
- mHoveredPoints.push_back( PointInfo( hoverPoint, time ) );
- hoverEvent.AddPoint( hoverPoint );
+ hoverPoint.SetState(PointState::STARTED); // The first hover event received
+ mHoveredPoints.push_back(PointInfo(hoverPoint, time));
+ hoverEvent.AddPoint(hoverPoint);
}
else
{
- PointInfo matchedPoint( point, time );
- std::swap( *match, matchedPoint );
+ PointInfo matchedPoint(point, time);
+ std::swap(*match, matchedPoint);
}
if(dispatchEvent == TouchEventCombiner::DISPATCH_TOUCH)
Reset();
// We should still tell core about the interruption.
- touchEvent.AddPoint( point );
- hoverEvent.AddPoint( point );
+ touchEvent.AddPoint(point);
+ hoverEvent.AddPoint(point);
dispatchEvent = TouchEventCombiner::DISPATCH_BOTH;
break;
}
return dispatchEvent;
}
-void TouchEventCombiner::SetMinimumMotionTimeThreshold( uint32_t minTime )
+void TouchEventCombiner::SetMinimumMotionTimeThreshold(uint32_t minTime)
{
mMinMotionTime = minTime;
}
-void TouchEventCombiner::SetMinimumMotionDistanceThreshold( float minDistance )
+void TouchEventCombiner::SetMinimumMotionDistanceThreshold(float minDistance)
{
- DALI_ASSERT_ALWAYS( minDistance >= 0.0f && "Negative values not allowed\n" );
+ DALI_ASSERT_ALWAYS(minDistance >= 0.0f && "Negative values not allowed\n");
mMinMotionDistance.x = mMinMotionDistance.y = minDistance;
}
-void TouchEventCombiner::SetMinimumMotionDistanceThreshold( float minXDistance, float minYDistance )
+void TouchEventCombiner::SetMinimumMotionDistanceThreshold(float minXDistance, float minYDistance)
{
- DALI_ASSERT_ALWAYS( minXDistance >= 0.0f && minYDistance >= 0.0f && "Negative values not allowed\n" );
+ DALI_ASSERT_ALWAYS(minXDistance >= 0.0f && minYDistance >= 0.0f && "Negative values not allowed\n");
mMinMotionDistance.x = minXDistance;
mMinMotionDistance.y = minYDistance;
}
-void TouchEventCombiner::SetMinimumMotionDistanceThreshold( Vector2 minDistance )
+void TouchEventCombiner::SetMinimumMotionDistanceThreshold(Vector2 minDistance)
{
- DALI_ASSERT_ALWAYS( minDistance.x >= 0.0f && minDistance.y >= 0.0f && "Negative values not allowed\n" );
+ DALI_ASSERT_ALWAYS(minDistance.x >= 0.0f && minDistance.y >= 0.0f && "Negative values not allowed\n");
mMinMotionDistance = minDistance;
}
#define DALI_INTEGRATION_TOUCH_EVENT_COMBINER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
+#include <dali/integration-api/events/point.h>
#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/math/vector2.h>
-#include <dali/integration-api/events/point.h>
namespace Dali
{
-
namespace Integration
{
-
struct TouchEvent;
struct HoverEvent;
class DALI_CORE_API TouchEventCombiner
{
public:
-
// Enumerations
enum EventDispatchType
{
- DISPATCH_TOUCH, ///< The touch event should be dispatched.
- DISPATCH_HOVER, ///< The hover event should be dispatched.
- DISPATCH_BOTH, ///< Both touch event and hover event should be dispatched.
- DISPATCH_NONE ///< Neither touch event nor hover event should be dispatched.
+ DISPATCH_TOUCH, ///< The touch event should be dispatched.
+ DISPATCH_HOVER, ///< The hover event should be dispatched.
+ DISPATCH_BOTH, ///< Both touch event and hover event should be dispatched.
+ DISPATCH_NONE ///< Neither touch event nor hover event should be dispatched.
};
/**
* @param[in] minMotionYDistance The minimum distance a finger has to be moved between vertical motion events.
* @note Will assert if any of the parameters is negative.
*/
- TouchEventCombiner( uint32_t minMotionTime, float minMotionXDistance, float minMotionYDistance );
+ TouchEventCombiner(uint32_t minMotionTime, float minMotionXDistance, float minMotionYDistance);
/**
* Construction with parameters.
* @param[in] minMotionDistance A Vector2 representing the minimum distance a finger has to be moved between horizontal and vertical motion events.
* @note Will assert if any of the parameters is negative.
*/
- TouchEventCombiner( uint32_t minMotionTime, Vector2 minMotionDistance );
+ TouchEventCombiner(uint32_t minMotionTime, Vector2 minMotionDistance);
/**
* Non virtual destructor
~TouchEventCombiner();
public:
-
/**
* Allows the caller to pass in a point which is processed and the TouchEvent and/or HoverEvent is appropriately filled with the new,
* and previously stored Point information.
*
* @return true if the point is beyond the different thresholds set thus, should be sent to core, false otherwise.
*/
- EventDispatchType GetNextTouchEvent( const Point& point, uint32_t time, TouchEvent& touchEvent, HoverEvent& hoverEvent );
+ EventDispatchType GetNextTouchEvent(const Point& point, uint32_t time, TouchEvent& touchEvent, HoverEvent& hoverEvent);
/**
* Sets the minimum time (in ms) that should occur between motion events.
* @param[in] minTime Minimum time between motion events.
*/
- void SetMinimumMotionTimeThreshold( uint32_t minTime );
+ void SetMinimumMotionTimeThreshold(uint32_t minTime);
/**
* Sets the minimum distance a finger has to be moved (both X and Y) between motion events.
* @param[in] minDistance The minimum distance between motion events.
* @note Will assert if parameter is negative.
*/
- void SetMinimumMotionDistanceThreshold( float minDistance );
+ void SetMinimumMotionDistanceThreshold(float minDistance);
/**
* Sets the minimum distance a finger has to be moved between motion events.
* @note Use this method if the X and Y threshold required is different.
* @note Will assert if any of the parameters is negative.
*/
- void SetMinimumMotionDistanceThreshold( float minXDistance, float minYDistance );
+ void SetMinimumMotionDistanceThreshold(float minXDistance, float minYDistance);
/**
* Sets the minimum distance a finger has to be moved between motion events.
* @note Use this method if the X and Y threshold required is different.
* @note Will assert if any of the parameters is negative.
*/
- void SetMinimumMotionDistanceThreshold( Vector2 minDistance );
+ void SetMinimumMotionDistanceThreshold(Vector2 minDistance);
/**
* Retrieves the minimum motion time threshold.
void Reset();
private:
-
struct PointInfo;
- typedef std::vector< PointInfo > PointInfoContainer;
- PointInfoContainer mPressedPoints; ///< A container of touched point and time.
- PointInfoContainer mHoveredPoints; ///< A container of hovered point and time.
+ typedef std::vector<PointInfo> PointInfoContainer;
+ PointInfoContainer mPressedPoints; ///< A container of touched point and time.
+ PointInfoContainer mHoveredPoints; ///< A container of hovered point and time.
- uint32_t mMinMotionTime; ///< The minimum time that should elapse before considering a new motion event.
- Vector2 mMinMotionDistance; ///< The minimum distance in the X and Y direction before considering a new motion event.
+ uint32_t mMinMotionTime; ///< The minimum time that should elapse before considering a new motion event.
+ Vector2 mMinMotionDistance; ///< The minimum distance in the X and Y direction before considering a new motion event.
};
} // namespace Integration
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
TouchEvent::TouchEvent()
-: MultiPointEvent( Touch )
+: MultiPointEvent(Touch)
{
}
-TouchEvent::TouchEvent( uint32_t time )
-: MultiPointEvent( Touch, time )
+TouchEvent::TouchEvent(uint32_t time)
+: MultiPointEvent(Touch, time)
{
}
namespace Dali
{
-
namespace Integration
{
-
/**
* An instance of this structure should be used by the adaptor to send a touch event to Dali core.
*
/**
* Virtual destructor
*/
- virtual ~TouchEvent();
+ ~TouchEvent() override;
};
} // namespace Integration
{
namespace Integration
{
+Dali::TouchEvent NewTouchEvent(uint32_t timeStamp, const TouchPoint& point)
+{
+ return NewTouchEvent(timeStamp, Integration::Point(point));
+}
-Dali::TouchEvent NewTouchEvent(uint32_t timestamp, const TouchPoint& point)
+Dali::TouchEvent NewTouchEvent(uint32_t timeStamp, const Dali::Integration::Point& point)
{
- Internal::TouchEventPtr touchEventImpl( new Internal::TouchEvent(timestamp) );
- touchEventImpl->AddPoint(Integration::Point(point));
+ Internal::TouchEventPtr touchEventImpl(new Internal::TouchEvent(timeStamp));
+ touchEventImpl->AddPoint(point);
Dali::TouchEvent handle(touchEventImpl.Get());
return handle;
}
*/
// INTERNAL INCLUDES
+#include <dali/devel-api/events/touch-point.h>
+#include <dali/integration-api/events/point.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/touch-event.h>
-#include <dali/devel-api/events/touch-point.h>
namespace Dali
{
-
namespace Integration
{
-
/**
* Create a new touch data handle from timestamp and touch point.
*
- * @param[in] timestamp The timestamp of the touch event.
+ * @param[in] timeStamp The time stamp of the touch event.
+ * @param[in] point The point on screen where the touch occurred.
+ * @return A new touch data handle.
+ */
+DALI_CORE_API Dali::TouchEvent NewTouchEvent(uint32_t timeStamp, const TouchPoint& point);
+
+/**
+ * Create a new touch data handle from timestamp and point.
+ *
+ * @param[in] timeStamp The time stamp of the touch event.
* @param[in] point The point on screen where the touch occurred.
* @return A new touch data handle.
*/
-DALI_CORE_API Dali::TouchEvent NewTouchEvent(uint32_t timestamp, const TouchPoint& point);
+DALI_CORE_API Dali::TouchEvent NewTouchEvent(uint32_t timeStamp, const Dali::Integration::Point& point);
} // namespace Integration
namespace Dali
{
-
namespace Integration
{
-
WheelEvent::WheelEvent()
-: Event( Wheel ),
- type( MOUSE_WHEEL ),
- direction( 0 ),
- modifiers( 0 ),
- point( Vector2::ZERO ),
- delta( 0 ),
- timeStamp( 0 )
+: Event(Wheel),
+ type(MOUSE_WHEEL),
+ direction(0),
+ modifiers(0),
+ point(Vector2::ZERO),
+ delta(0),
+ timeStamp(0)
{
}
-WheelEvent::WheelEvent( Type type, int direction, unsigned int modifiers, Vector2 point, int delta, unsigned int timeStamp )
-: Event( Wheel ),
- type( type ),
- direction( direction ),
- modifiers( modifiers ),
- point( point ),
- delta( delta ),
- timeStamp( timeStamp )
+WheelEvent::WheelEvent(Type type, int direction, unsigned int modifiers, Vector2 point, int delta, unsigned int timeStamp)
+: Event(Wheel),
+ type(type),
+ direction(direction),
+ modifiers(modifiers),
+ point(point),
+ delta(delta),
+ timeStamp(timeStamp)
{
}
namespace Dali
{
-
namespace Integration
{
-
/**
* An instance of this class should be used by the adaptor to send a wheel event to
* the Dali core.
*/
enum Type
{
- MOUSE_WHEEL, ///< Mouse wheel event
- CUSTOM_WHEEL ///< Custom wheel event
+ MOUSE_WHEEL, ///< Mouse wheel event
+ CUSTOM_WHEEL ///< Custom wheel event
};
/**
* @param[in] delta The offset of rolling (positive value means roll down, and negative value means roll up)
* @param[in] timeStamp The time the wheel is being rolled.
*/
- WheelEvent( Type type, int direction, unsigned int modifiers, Vector2 point, int delta, unsigned int timeStamp );
+ WheelEvent(Type type, int direction, unsigned int modifiers, Vector2 point, int delta, unsigned int timeStamp);
/**
* Virtual destructor
*/
- virtual ~WheelEvent();
+ ~WheelEvent() override;
// Data
*@copydoc Dali::WheelEvent::GetTime
*/
unsigned int timeStamp;
-
};
} // namespace Integration
#define DALI_INTEGRATION_GL_ABSTRACTION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
-
/* OpenGL ES 3.0 */
struct __GLsync;
namespace Dali
{
-
/**
* These types are equivalent to those in the GLES2 API.
* Dali objects should only access GL indirectly, through the Context API.
/* OpenGL ES 2.0 */
-typedef void GLvoid;
-typedef char GLchar;
-typedef unsigned int GLenum;
-typedef unsigned char GLboolean;
-typedef unsigned int GLbitfield;
-typedef int8_t GLbyte;
-typedef short GLshort;
-typedef int GLint;
-typedef int GLsizei;
-typedef uint8_t GLubyte;
-typedef unsigned short GLushort;
-typedef unsigned int GLuint;
-typedef float GLfloat;
-typedef float GLclampf;
-typedef int GLfixed;
-typedef signed long int GLintptr;
-typedef signed long int GLsizeiptr;
+using GLvoid = void;
+using GLchar = char;
+using GLenum = unsigned int;
+using GLboolean = unsigned char;
+using GLbitfield = unsigned int;
+using GLbyte = int8_t;
+using GLshort = short;
+using GLint = int;
+using GLsizei = int;
+using GLubyte = uint8_t;
+using GLushort = unsigned short;
+using GLuint = unsigned int;
+using GLfloat = float;
+using GLclampf = float;
+using GLfixed = int;
+using GLintptr = long;
+using GLsizeiptr = long;
/* OpenGL ES 3.0 */
-typedef unsigned short GLhalf;
-typedef int64_t GLint64;
-typedef uint64_t GLuint64;
-typedef __GLsync* GLsync;
+using GLhalf = unsigned short;
+using GLint64 = int64_t;
+using GLuint64 = uint64_t;
+using GLsync = __GLsync*;
namespace Integration
{
-
/**
* GlAbstraction is an abstract interface, used to access OpenGL services.
* A concrete implementation must be created for each platform, and provided when creating the
class GlAbstraction
{
protected:
-
/**
* Virtual protected destructor, no deletion through this interface
*/
- virtual ~GlAbstraction() {}
+ virtual ~GlAbstraction()
+ {
+ }
public:
/**
* @param[in] isSubImage Boolian value for the whether the image is subimage or not
* @return Whether the texture will be convert or not.
*/
- virtual bool TextureRequiresConverting( const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage ) const = 0;
+ virtual bool TextureRequiresConverting(const GLenum imageGlFormat, const GLenum textureGlFormat, const bool isSubImage) const = 0;
/**
* The number of texture units an implementation supports is implementation dependent, but must be at least 8.
static const unsigned int MIN_TEXTURE_UNIT_LIMIT = 8;
/* OpenGL ES 2.0 */
-
+ // clang-format off
virtual void ActiveTexture (GLenum texture) = 0;
virtual void AttachShader (GLuint program, GLuint shader) = 0;
virtual void BindAttribLocation (GLuint program, GLuint index, const char* name) = 0;
virtual void TexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) = 0;
virtual void TexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = 0;
virtual void GetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) = 0;
-
+ // clang-format on
};
} // namespace Integration
{
namespace Integration
{
-
/**
* This abstraction defines the interface for accessing GL context.
*/
virtual ~GlContextHelperAbstraction() = default;
public:
-
/**
* @brief Switch to the surfaceless GL context
*/
#define DALI_INTERNAL_GL_DEFINES_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
+// clang-format off
+
/* OpenGL ES 2.0 */
/* ClearBufferMask */
#define DALI_INTEGRATION_GL_SYNC_ABSTRACTION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
namespace Integration
{
-
/**
* This abstraction defines an API for syncing CPU with GPU.
* A typical use case is to determine when GL draw calls have finished drawing
/**
* Virtual protected destructor, no deletion through this interface
*/
- virtual ~GlSyncAbstraction() {}
+ virtual ~GlSyncAbstraction()
+ {
+ }
public:
-
class SyncObject
{
protected:
* Core from deleting SyncObjects - only Adaptor implementation is able to delete
* them.
*/
- virtual ~SyncObject() {}
+ virtual ~SyncObject()
+ {
+ }
public:
-
/**
* Determine if the synchronisation object has been signalled.
* @return false if the sync object has not been signalled, true if it has been signalled (and
namespace Dali
{
-
namespace Integration
{
-
-void SetPanGesturePredictionMode( int mode )
+void SetPanGesturePredictionMode(int mode)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGesturePredictionMode(mode);
}
-void SetPanGesturePredictionAmount( unsigned int amount )
+void SetPanGesturePredictionAmount(unsigned int amount)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGesturePredictionAmount(amount);
}
-void SetPanGestureMaximumPredictionAmount( unsigned int amount )
+void SetPanGestureMaximumPredictionAmount(unsigned int amount)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGestureMaximumPredictionAmount(amount);
}
-void SetPanGestureMinimumPredictionAmount( unsigned int amount )
+void SetPanGestureMinimumPredictionAmount(unsigned int amount)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGestureMinimumPredictionAmount(amount);
}
-void SetPanGesturePredictionAmountAdjustment( unsigned int amount )
+void SetPanGesturePredictionAmountAdjustment(unsigned int amount)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGesturePredictionAmountAdjustment(amount);
}
-void SetPanGestureSmoothingMode( int mode )
+void SetPanGestureSmoothingMode(int mode)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGestureSmoothingMode(mode);
}
-void SetPanGestureSmoothingAmount( float amount )
+void SetPanGestureSmoothingAmount(float amount)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
eventProcessor.SetPanGestureSmoothingAmount(amount);
}
-void SetPanGestureUseActualTimes( bool value )
+void SetPanGestureUseActualTimes(bool value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureUseActualTimes( value );
+ eventProcessor.SetPanGestureUseActualTimes(value);
}
-void SetPanGestureInterpolationTimeRange( int value )
+void SetPanGestureInterpolationTimeRange(int value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureInterpolationTimeRange( value );
+ eventProcessor.SetPanGestureInterpolationTimeRange(value);
}
-void SetPanGestureScalarOnlyPredictionEnabled( bool value )
+void SetPanGestureScalarOnlyPredictionEnabled(bool value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureScalarOnlyPredictionEnabled( value );
+ eventProcessor.SetPanGestureScalarOnlyPredictionEnabled(value);
}
-void SetPanGestureTwoPointPredictionEnabled( bool value )
+void SetPanGestureTwoPointPredictionEnabled(bool value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureTwoPointPredictionEnabled( value );
+ eventProcessor.SetPanGestureTwoPointPredictionEnabled(value);
}
-void SetPanGestureTwoPointInterpolatePastTime( int value )
+void SetPanGestureTwoPointInterpolatePastTime(int value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureTwoPointInterpolatePastTime( value );
+ eventProcessor.SetPanGestureTwoPointInterpolatePastTime(value);
}
-void SetPanGestureTwoPointVelocityBias( float value )
+void SetPanGestureTwoPointVelocityBias(float value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureTwoPointVelocityBias( value );
+ eventProcessor.SetPanGestureTwoPointVelocityBias(value);
}
-void SetPanGestureTwoPointAccelerationBias( float value )
+void SetPanGestureTwoPointAccelerationBias(float value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureTwoPointAccelerationBias( value );
+ eventProcessor.SetPanGestureTwoPointAccelerationBias(value);
}
-void SetPanGestureMultitapSmoothingRange( int value )
+void SetPanGestureMultitapSmoothingRange(int value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureMultitapSmoothingRange( value );
+ eventProcessor.SetPanGestureMultitapSmoothingRange(value);
}
-void SetPanGestureMinimumDistance( int value )
+void SetPanGestureMinimumDistance(int value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureMinimumDistance( value );
+ eventProcessor.SetPanGestureMinimumDistance(value);
}
-void SetPanGestureMinimumPanEvents( int value )
+void SetPanGestureMinimumPanEvents(int value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPanGestureMinimumPanEvents( value );
+ eventProcessor.SetPanGestureMinimumPanEvents(value);
}
-void SetPinchGestureMinimumDistance( float value )
+void SetPinchGestureMinimumDistance(float value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPinchGestureMinimumDistance( value );
+ eventProcessor.SetPinchGestureMinimumDistance(value);
}
-void SetPinchGestureMinimumTouchEvents( uint32_t value )
+void SetPinchGestureMinimumTouchEvents(uint32_t value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPinchGestureMinimumTouchEvents( value );
+ eventProcessor.SetPinchGestureMinimumTouchEvents(value);
}
-void SetPinchGestureMinimumTouchEventsAfterStart( uint32_t value )
+void SetPinchGestureMinimumTouchEventsAfterStart(uint32_t value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetPinchGestureMinimumTouchEventsAfterStart( value );
+ eventProcessor.SetPinchGestureMinimumTouchEventsAfterStart(value);
}
-void SetRotationGestureMinimumTouchEvents( uint32_t value )
+void SetRotationGestureMinimumTouchEvents(uint32_t value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetRotationGestureMinimumTouchEvents( value );
+ eventProcessor.SetRotationGestureMinimumTouchEvents(value);
}
-void SetRotationGestureMinimumTouchEventsAfterStart( uint32_t value )
+void SetRotationGestureMinimumTouchEventsAfterStart(uint32_t value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetRotationGestureMinimumTouchEventsAfterStart( value );
+ eventProcessor.SetRotationGestureMinimumTouchEventsAfterStart(value);
}
-void SetLongPressMinimumHoldingTime( unsigned int value )
+void SetLongPressMinimumHoldingTime(unsigned int value)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- eventProcessor.SetLongPressMinimumHoldingTime( value );
+ eventProcessor.SetLongPressMinimumHoldingTime(value);
}
-
} // namespace Integration
} // namespace Dali
#define DALI_INTEGRATION_INPUT_OPTIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
/**
* @brief Called by adaptor to set the pan gesture prediction mode from
* an environment variable
* @pre Should be called after Core creation.
* @param mode The pan gesture prediction mode.
*/
-DALI_CORE_API void SetPanGesturePredictionMode( int mode );
+DALI_CORE_API void SetPanGesturePredictionMode(int mode);
/**
* @brief Called by adaptor to set the prediction amount of the pan gesture
*
* @param[in] amount The prediction amount in milliseconds
*/
-DALI_CORE_API void SetPanGestureMaximumPredictionAmount( unsigned int amount );
+DALI_CORE_API void SetPanGestureMaximumPredictionAmount(unsigned int amount);
/**
* @brief Sets the lower bound of the prediction amount for clamping
*
* @param[in] amount The prediction amount in milliseconds
*/
-DALI_CORE_API void SetPanGestureMinimumPredictionAmount( unsigned int amount );
+DALI_CORE_API void SetPanGestureMinimumPredictionAmount(unsigned int amount);
/**
* @brief Sets the prediction amount to adjust when the pan velocity is changed
*
* @param[in] amount The prediction amount in milliseconds
*/
-DALI_CORE_API void SetPanGesturePredictionAmountAdjustment( unsigned int amount );
+DALI_CORE_API void SetPanGesturePredictionAmountAdjustment(unsigned int amount);
/**
* @brief Called to set how pan gestures smooth input
*
* @param[in] mode The smoothing mode to use
*/
-DALI_CORE_API void SetPanGestureSmoothingMode( int mode );
+DALI_CORE_API void SetPanGestureSmoothingMode(int mode);
/**
* @brief Sets the smoothing amount of the pan gesture
*
* @param[in] amount The smoothing amount [0.0f,1.0f] - 0.0f would be no smoothing, 1.0f maximum smoothing
*/
-DALI_CORE_API void SetPanGestureSmoothingAmount( float amount );
+DALI_CORE_API void SetPanGestureSmoothingAmount(float amount);
/**
* @brief Sets whether to use actual times of the real gesture and frames or not.
*
* @param[in] value True = use actual times, False = use perfect values
*/
-DALI_CORE_API void SetPanGestureUseActualTimes( bool value );
+DALI_CORE_API void SetPanGestureUseActualTimes(bool value);
/**
* @brief Sets the interpolation time range (ms) of past points to use (with weights) when interpolating.
*
* @param[in] value Time range in ms
*/
-DALI_CORE_API void SetPanGestureInterpolationTimeRange( int value );
+DALI_CORE_API void SetPanGestureInterpolationTimeRange(int value);
/**
* @brief Sets whether to use scalar only prediction, which when enabled, ignores acceleration.
*
* @param[in] value True = use scalar prediction only
*/
-DALI_CORE_API void SetPanGestureScalarOnlyPredictionEnabled( bool value );
+DALI_CORE_API void SetPanGestureScalarOnlyPredictionEnabled(bool value);
/**
* @brief Sets whether to use two point prediction. This combines two interpolated points to get more steady acceleration and velocity values.
*
* @param[in] value True = use two point prediction
*/
-DALI_CORE_API void SetPanGestureTwoPointPredictionEnabled( bool value );
+DALI_CORE_API void SetPanGestureTwoPointPredictionEnabled(bool value);
/**
* @brief Sets the time in the past to interpolate the second point when using two point interpolation.
*
* @param[in] value Time in past in ms
*/
-DALI_CORE_API void SetPanGestureTwoPointInterpolatePastTime( int value );
+DALI_CORE_API void SetPanGestureTwoPointInterpolatePastTime(int value);
/**
* @brief Sets the two point velocity bias. This is the ratio of first and second points to use for velocity.
*
* @param[in] value 0.0f = 100% first point. 1.0f = 100% of second point.
*/
-DALI_CORE_API void SetPanGestureTwoPointVelocityBias( float value );
+DALI_CORE_API void SetPanGestureTwoPointVelocityBias(float value);
/**
* @brief Sets the two point acceleration bias. This is the ratio of first and second points to use for acceleration.
*
* @param[in] value 0.0f = 100% first point. 1.0f = 100% of second point.
*/
-DALI_CORE_API void SetPanGestureTwoPointAccelerationBias( float value );
+DALI_CORE_API void SetPanGestureTwoPointAccelerationBias(float value);
/**
* @brief Sets the range of time (ms) of points in the history to perform multitap smoothing with (if enabled).
*
* @param[in] value Time in past in ms
*/
-DALI_CORE_API void SetPanGestureMultitapSmoothingRange( int value );
+DALI_CORE_API void SetPanGestureMultitapSmoothingRange(int value);
/**
* @brief Sets the minimum distance required to start a pan gesture
*
* @param[in] value Distance to move
*/
-DALI_CORE_API void SetPanGestureMinimumDistance( int value );
+DALI_CORE_API void SetPanGestureMinimumDistance(int value);
/**
* @brief Sets the minimum number of touch events to start a pan
*
* @param[in] value Number of pan events
*/
-DALI_CORE_API void SetPanGestureMinimumPanEvents( int value );
+DALI_CORE_API void SetPanGestureMinimumPanEvents(int value);
/**
* @brief Sets the minimum distance required to start a pinch gesture
*
* @param[in] value Distance to move in pixels
*/
-DALI_CORE_API void SetPinchGestureMinimumDistance( float value );
+DALI_CORE_API void SetPinchGestureMinimumDistance(float value);
/**
* @brief Sets the minimum touch events required before a pinch can be started
*
* @param[in] value The number of touch events
*/
-DALI_CORE_API void SetPinchGestureMinimumTouchEvents( uint32_t value );
+DALI_CORE_API void SetPinchGestureMinimumTouchEvents(uint32_t value);
/**
* @brief Sets the minimum touch events required after a pinch started
*
* @param[in] value The number of touch events
*/
-DALI_CORE_API void SetPinchGestureMinimumTouchEventsAfterStart( uint32_t value );
+DALI_CORE_API void SetPinchGestureMinimumTouchEventsAfterStart(uint32_t value);
/**
* @brief Sets the minimum touch events required before a rotation can be started
*
* @param[in] value The number of touch events
*/
-DALI_CORE_API void SetRotationGestureMinimumTouchEvents( uint32_t value );
+DALI_CORE_API void SetRotationGestureMinimumTouchEvents(uint32_t value);
/**
* @brief Sets the minimum touch events required after a rotation started
*
* @param[in] value The number of touch events
*/
-DALI_CORE_API void SetRotationGestureMinimumTouchEventsAfterStart( uint32_t value );
+DALI_CORE_API void SetRotationGestureMinimumTouchEventsAfterStart(uint32_t value);
/**
* @brief Sets the minimum holding time required to be recognized as a long press gesture
*
* @param[in] value The time value in milliseconds
*/
-DALI_CORE_API void SetLongPressMinimumHoldingTime( unsigned int value );
+DALI_CORE_API void SetLongPressMinimumHoldingTime(unsigned int value);
} // namespace Integration
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
-LocklessBuffer::LocklessBuffer( uint32_t size )
-: mState( R0W1 ),
- mSize( size )
+LocklessBuffer::LocklessBuffer(uint32_t size)
+: mState(R0W1),
+ mSize(size)
{
// allocate memory to speed up operation
mBuffer[0] = new uint8_t[size];
mBuffer[1] = new uint8_t[size];
- memset (mBuffer[0], 0, size );
- memset (mBuffer[1], 0, size );
+ memset(mBuffer[0], 0, size);
+ memset(mBuffer[1], 0, size);
}
LocklessBuffer::~LocklessBuffer()
delete[] mBuffer[1];
}
-void LocklessBuffer::Write( const uint8_t *src, uint32_t size )
+void LocklessBuffer::Write(const uint8_t* src, uint32_t size)
{
- DALI_ASSERT_ALWAYS( size <= mSize );
+ DALI_ASSERT_ALWAYS(size <= mSize);
// set WRITING bit
- BufferState currentState( __sync_fetch_and_or( &mState, WRITING ) );
- DALI_ASSERT_DEBUG( !(currentState & WRITING_MASK) ); // WRITING bit should never be set when we get here
+ BufferState currentState(__sync_fetch_and_or(&mState, WRITING));
+ DALI_ASSERT_DEBUG(!(currentState & WRITING_MASK)); // WRITING bit should never be set when we get here
// copy data to current write buffer, negate state to get actual index (recap: R0W1 = 0, R1W0 = 1)
const unsigned int index = (currentState & WRITE_BUFFER_MASK);
- memcpy( mBuffer[index], src, size );
+ memcpy(mBuffer[index], src, size);
// unset WRITING bit, set UPDATED bit
- BufferState checkState = __sync_val_compare_and_swap( &mState,
- static_cast<BufferState>(currentState | WRITING),
- static_cast<BufferState>(index | UPDATED) );
+ BufferState checkState = __sync_val_compare_and_swap(&mState,
+ static_cast<BufferState>(currentState | WRITING),
+ static_cast<BufferState>(index | UPDATED));
- DALI_ASSERT_DEBUG( checkState & WRITING );
+ DALI_ASSERT_DEBUG(checkState & WRITING);
(void)checkState; // Avoid unused variable warning
}
const uint8_t* LocklessBuffer::Read()
{
// current state (only to avoid multiple memory reads with volatile variable)
- BufferState currentState( mState );
- BufferState currentWriteBuf( static_cast<BufferState>( currentState & WRITE_BUFFER_MASK ) );
+ BufferState currentState(mState);
+ BufferState currentWriteBuf(static_cast<BufferState>(currentState & WRITE_BUFFER_MASK));
- if( currentState & UPDATED_MASK )
+ if(currentState & UPDATED_MASK)
{
// Try to swap buffers.
// This will set mState to 1 if readbuffer 0 was updated, 0 if readbuffer 1 was updated and fail if WRITING is set
- if( __sync_bool_compare_and_swap( &mState,
- static_cast<BufferState>(currentWriteBuf | UPDATED),
- static_cast<BufferState>(!currentWriteBuf) ) )
+ if(__sync_bool_compare_and_swap(&mState,
+ static_cast<BufferState>(currentWriteBuf | UPDATED),
+ static_cast<BufferState>(!currentWriteBuf)))
{
// swap successful
return mBuffer[currentWriteBuf];
return static_cast<unsigned int>(mSize);
}
-} // Internal
+} // namespace Integration
-} // Dali
+} // namespace Dali
#define DALI_INTEGRATION_LOCKLESS_BUFFER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <cstdint> // uint32_t, uint8_t
// INTERNAL INCLUDES
-#include <cstring>
-#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/common/vector-wrapper.h>
+#include <cstring>
namespace Dali
{
-
namespace Integration
{
-
/**
* The LocklessBuffer class implements double buffering eligible for multi-(two) threaded use,
* where it's possible to read from one thread and write from another
*/
class DALI_CORE_API LocklessBuffer
{
-
public:
/**
* Constructor.
* @param[in] size The size of buffers in bytes.
*/
- LocklessBuffer( uint32_t size );
+ LocklessBuffer(uint32_t size);
/**
* Destructor.
* @param[in] src data source
* @param[in] size size of data in bytes
*/
- void Write( const uint8_t *src, uint32_t size );
+ void Write(const uint8_t* src, uint32_t size);
/**
* Try to swap buffers and read data.
*/
enum BufferState
{
- R0W1 = 0, ///< Read from buffer 0 write to buffer 1
- R1W0 = 1, ///< Read from buffer 1 write to buffer 0
- WRITING = 2, ///< Currently writing to buffer
- UPDATED = 4, ///< Swapping buffer required; there is new data available
+ R0W1 = 0, ///< Read from buffer 0 write to buffer 1
+ R1W0 = 1, ///< Read from buffer 1 write to buffer 0
+ WRITING = 2, ///< Currently writing to buffer
+ UPDATED = 4, ///< Swapping buffer required; there is new data available
WRITE_BUFFER_MASK = 1, ///< indicates which buffer to write to
WRITING_MASK = 2, ///< indicates whether currently writing
UPDATED_MASK = 4 ///< indicates whether new data is available
};
private:
- LocklessBuffer(); ///< undefined default constructor, need to give size on construction
- LocklessBuffer( const LocklessBuffer& ); ///< undefined copy constructor
- LocklessBuffer& operator=( const LocklessBuffer& ); ///< undefined assignment operator
+ LocklessBuffer(); ///< undefined default constructor, need to give size on construction
+ LocklessBuffer(const LocklessBuffer&); ///< undefined copy constructor
+ LocklessBuffer& operator=(const LocklessBuffer&); ///< undefined assignment operator
private:
uint8_t* mBuffer[2]; ///< bitmap buffers
uint32_t mSize; ///< size of buffers
};
-} // Internal
+} // namespace Integration
-} // Dali
+} // namespace Dali
#endif // DALI_INTEGRATION_LOCKLESS_BUFFER_H
#define DALI_INTEGRATION_PLATFORM_ABSTRACTION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/integration-api/bitmap.h>
#include <dali/integration-api/resource-types.h>
-#include <dali/public-api/images/image-operations.h>
#include <dali/public-api/common/dali-vector.h>
+#include <dali/public-api/images/image-operations.h>
#include <dali/public-api/signals/callback.h>
namespace Dali
{
-
namespace Integration
{
-typedef uint32_t ResourceId;
-typedef IntrusivePtr<Dali::RefObject> ResourcePointer;
+using ResourceId = uint32_t;
+using ResourcePointer = IntrusivePtr<Dali::RefObject>;
/**
* PlatformAbstraction is an abstract interface, used by Dali to access platform specific services.
class PlatformAbstraction
{
public:
-
// Resource Loading
/**
* flip the image, e.g., from portrait to landscape.
* @return dimensions that image will have if it is loaded with given parameters.
*/
- virtual ImageDimensions GetClosestImageSize( const std::string& filename,
- ImageDimensions size = ImageDimensions( 0, 0 ),
- FittingMode::Type fittingMode = FittingMode::SHRINK_TO_FIT,
- SamplingMode::Type samplingMode = SamplingMode::BOX,
- bool orientationCorrection = true) = 0;
+ virtual ImageDimensions GetClosestImageSize(const std::string& filename,
+ ImageDimensions size = ImageDimensions(0, 0),
+ FittingMode::Type fittingMode = FittingMode::SHRINK_TO_FIT,
+ SamplingMode::Type samplingMode = SamplingMode::BOX,
+ bool orientationCorrection = true) = 0;
/**
* @brief Determine the size of an image the resource loaders will provide when
* flip the image, e.g., from portrait to landscape.
* @return dimensions that image will have if it is loaded with given parameters.
*/
- virtual ImageDimensions GetClosestImageSize( ResourcePointer resourceBuffer,
- ImageDimensions size = ImageDimensions( 0, 0 ),
- FittingMode::Type fittingMode = FittingMode::SHRINK_TO_FIT,
- SamplingMode::Type samplingMode = SamplingMode::BOX,
- bool orientationCorrection = true) = 0;
+ virtual ImageDimensions GetClosestImageSize(ResourcePointer resourceBuffer,
+ ImageDimensions size = ImageDimensions(0, 0),
+ FittingMode::Type fittingMode = FittingMode::SHRINK_TO_FIT,
+ SamplingMode::Type samplingMode = SamplingMode::BOX,
+ bool orientationCorrection = true) = 0;
/**
* Request an image from the native filesystem. This is a synchronous request, i.e.
* @param[in] resourcePath The path to the resource
* @return A pointer to a ref-counted resource
*/
- virtual ResourcePointer LoadImageSynchronously( const BitmapResourceType& resourceType, const std::string& resourcePath ) = 0;
+ virtual ResourcePointer LoadImageSynchronously(const BitmapResourceType& resourceType, const std::string& resourcePath) = 0;
/**
* Decode a buffer of data synchronously.
*
* @return A pointer to the decoded buffer.
*/
- virtual BitmapPtr DecodeBuffer( const BitmapResourceType& resourceType, uint8_t * buffer, size_t bufferSize ) = 0;
+ virtual BitmapPtr DecodeBuffer(const BitmapResourceType& resourceType, uint8_t* buffer, size_t bufferSize) = 0;
/**
* Load a shader binary file into a buffer
* @param[out] buffer A buffer to receive the file.
* @result true if the file is loaded.
*/
- virtual bool LoadShaderBinaryFile( const std::string& filename, Dali::Vector< uint8_t >& buffer ) const = 0;
+ virtual bool LoadShaderBinaryFile(const std::string& filename, Dali::Vector<uint8_t>& buffer) const = 0;
/**
* Save a shader binary file to the resource file system.
* @param[in] numbytes Size of the buffer.
* @result true if the file is saved, else false.
*/
- virtual bool SaveShaderBinaryFile( const std::string& filename, const uint8_t * buffer, uint32_t numBytes ) const = 0;
+ virtual bool SaveShaderBinaryFile(const std::string& filename, const uint8_t* buffer, uint32_t numBytes) const = 0;
/**
* Sets a callback to occur in the future
* @param[in] callback function to call when the timer expires
* @result a timer reference ID, to be used for cancelling the timer
*/
- virtual uint32_t StartTimer( uint32_t milliseconds, CallbackBase* callback ) = 0;
+ virtual uint32_t StartTimer(uint32_t milliseconds, CallbackBase* callback) = 0;
/**
* Cancels a running timer
* @param[in] timerId the ID reference returned when the timer was started
*/
- virtual void CancelTimer ( uint32_t timerId ) = 0;
+ virtual void CancelTimer(uint32_t timerId) = 0;
protected:
-
/**
* Virtual destructor.
*/
- virtual ~PlatformAbstraction() {}
+ virtual ~PlatformAbstraction()
+ {
+ }
}; // class PlatformAbstraction
#define DALI_INTEGRATION_PROCESSOR_INTERFACE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
/**
* Interface to enable classes to be processed after the event loop. Classes are processed
* in the order they are registered.
virtual void Process() = 0;
protected:
-
/**
* Virtual protected destructor
*/
- virtual ~Processor() { }
+ virtual ~Processor()
+ {
+ }
};
-} // Dali
+} // namespace Integration
-} // Integration
+} // namespace Dali
#endif // DALI_INTEGRATION_PROCESSOR_INTERFACE_H
\ No newline at end of file
#include <dali/internal/update/animation/scene-graph-animation.h>
#include <dali/internal/update/animation/scene-graph-constraint.h>
-
#include <dali/internal/update/nodes/node.h>
#include <dali/internal/update/nodes/scene-graph-layer.h>
#include <dali/internal/update/rendering/scene-graph-renderer.h>
#include <dali/internal/render/renderers/render-geometry.h>
-#include <dali/internal/render/renderers/render-vertex-buffer.h>
#include <dali/internal/render/renderers/render-renderer.h>
#include <dali/internal/render/renderers/render-sampler.h>
+#include <dali/internal/render/renderers/render-vertex-buffer.h>
#include <dali/internal/update/render-tasks/scene-graph-camera.h>
using Dali::Internal::GestureEventProcessor;
namespace Dali
{
-
namespace Integration
{
-
-void EnableProfiling( ProfilingType type )
+void EnableProfiling(ProfilingType type)
{
GestureEventProcessor& eventProcessor = ThreadLocalStorage::Get().GetGestureEventProcessor();
- switch( type )
+ switch(type)
{
case PROFILING_TYPE_PAN_GESTURE:
{
namespace Profiling
{
-
const std::size_t ANIMATION_MEMORY_SIZE(
- sizeof( Internal::Animation ) +
- sizeof( Internal::AnimatorConnector<float> ) +
- sizeof( Internal::SceneGraph::Animation ) );
+ sizeof(Internal::Animation) +
+ sizeof(Internal::AnimatorConnector<float>) +
+ sizeof(Internal::SceneGraph::Animation));
const std::size_t CONSTRAINT_MEMORY_SIZE(
- sizeof( Internal::Constraint<float> ) +
- sizeof( Internal::SceneGraph::Constraint<float, Internal::PropertyAccessor<float> > ) );
+ sizeof(Internal::Constraint<float>) +
+ sizeof(Internal::SceneGraph::Constraint<float, Internal::PropertyAccessor<float> >));
const std::size_t ACTOR_MEMORY_SIZE(
- sizeof( Internal::Actor ) +
- sizeof( Internal::SceneGraph::Node ) );
+ sizeof(Internal::Actor) +
+ sizeof(Internal::SceneGraph::Node));
const std::size_t CAMERA_ACTOR_MEMORY_SIZE(
- sizeof( Internal::CameraActor ) +
- sizeof( Internal::SceneGraph::Node ) +
- sizeof( Internal::SceneGraph::Camera ) );
+ sizeof(Internal::CameraActor) +
+ sizeof(Internal::SceneGraph::Node) +
+ sizeof(Internal::SceneGraph::Camera));
const std::size_t LAYER_MEMORY_SIZE(
- sizeof( Internal::Layer ) +
- sizeof( Internal::SceneGraph::Layer ) );
+ sizeof(Internal::Layer) +
+ sizeof(Internal::SceneGraph::Layer));
const std::size_t RENDERER_MEMORY_SIZE(
- sizeof( Internal::Renderer ) +
- sizeof( Internal::SceneGraph::Renderer ) +
- sizeof( Internal::Render::Renderer ) );
+ sizeof(Internal::Renderer) +
+ sizeof(Internal::SceneGraph::Renderer) +
+ sizeof(Internal::Render::Renderer));
const std::size_t GEOMETRY_MEMORY_SIZE(
- sizeof( Internal::Geometry ) +
- sizeof( Internal::Render::Geometry) );
+ sizeof(Internal::Geometry) +
+ sizeof(Internal::Render::Geometry));
const std::size_t PROPERTY_BUFFER_MEMORY_SIZE(
- sizeof( Internal::VertexBuffer ) +
- sizeof( Internal::Render::VertexBuffer ) );
+ sizeof(Internal::VertexBuffer) +
+ sizeof(Internal::Render::VertexBuffer));
const std::size_t TEXTURE_SET_MEMORY_SIZE(
- sizeof( Internal::TextureSet ) +
- sizeof( Internal::SceneGraph::TextureSet ) );
+ sizeof(Internal::TextureSet) +
+ sizeof(Internal::SceneGraph::TextureSet));
const std::size_t SAMPLER_MEMORY_SIZE(
- sizeof( Internal::Sampler ) +
- sizeof( Internal::Render::Sampler ) );
+ sizeof(Internal::Sampler) +
+ sizeof(Internal::Render::Sampler));
const std::size_t SHADER_MEMORY_SIZE(
- sizeof( Internal::Shader ) +
- sizeof( Internal::SceneGraph::Shader ) );
+ sizeof(Internal::Shader) +
+ sizeof(Internal::SceneGraph::Shader));
} // namespace Profiling
#define DALI_INTEGRATION_PROFILING_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
enum ProfilingType
{
PROFILING_TYPE_PAN_GESTURE,
* @pre Should be called after Core creation.
* @param type The type of profiling information to output.
*/
-DALI_CORE_API void EnableProfiling( ProfilingType type );
-
+DALI_CORE_API void EnableProfiling(ProfilingType type);
namespace Profiling
{
-
-DALI_CORE_API extern const std::size_t ANIMATION_MEMORY_SIZE; ///< Total size of animation and associated internal objects
-DALI_CORE_API extern const std::size_t CONSTRAINT_MEMORY_SIZE; ///< Total size of constraint and associated internal objects
-DALI_CORE_API extern const std::size_t ACTOR_MEMORY_SIZE; ///< Total size of actor and associated internal objects
-DALI_CORE_API extern const std::size_t CAMERA_ACTOR_MEMORY_SIZE; ///< Total size of camera actor and associated internal objects
-DALI_CORE_API extern const std::size_t IMAGE_ACTOR_MEMORY_SIZE; ///< Total size of image actor and associated internal objects
-DALI_CORE_API extern const std::size_t LAYER_MEMORY_SIZE; ///< Total size of layer and associated internal objects
-DALI_CORE_API extern const std::size_t IMAGE_MEMORY_SIZE; ///< Total size of image and associated internal objects
-
-DALI_CORE_API extern const std::size_t RENDERER_MEMORY_SIZE; ///< Total size of renderer and associated internal objects
-DALI_CORE_API extern const std::size_t GEOMETRY_MEMORY_SIZE; ///< Total size of geometry and associated internal objects
-DALI_CORE_API extern const std::size_t PROPERTY_BUFFER_MEMORY_SIZE; ///< Total size of property-0buffer and associated internal objects
+DALI_CORE_API extern const std::size_t ANIMATION_MEMORY_SIZE; ///< Total size of animation and associated internal objects
+DALI_CORE_API extern const std::size_t CONSTRAINT_MEMORY_SIZE; ///< Total size of constraint and associated internal objects
+DALI_CORE_API extern const std::size_t ACTOR_MEMORY_SIZE; ///< Total size of actor and associated internal objects
+DALI_CORE_API extern const std::size_t CAMERA_ACTOR_MEMORY_SIZE; ///< Total size of camera actor and associated internal objects
+DALI_CORE_API extern const std::size_t IMAGE_ACTOR_MEMORY_SIZE; ///< Total size of image actor and associated internal objects
+DALI_CORE_API extern const std::size_t LAYER_MEMORY_SIZE; ///< Total size of layer and associated internal objects
+DALI_CORE_API extern const std::size_t IMAGE_MEMORY_SIZE; ///< Total size of image and associated internal objects
+DALI_CORE_API extern const std::size_t RENDERER_MEMORY_SIZE; ///< Total size of renderer and associated internal objects
+DALI_CORE_API extern const std::size_t GEOMETRY_MEMORY_SIZE; ///< Total size of geometry and associated internal objects
+DALI_CORE_API extern const std::size_t PROPERTY_BUFFER_MEMORY_SIZE; ///< Total size of property-0buffer and associated internal objects
DALI_CORE_API extern const std::size_t TEXTURE_SET_MEMORY_SIZE; ///< Total size of TextureSet and associated internal objects
-DALI_CORE_API extern const std::size_t SAMPLER_MEMORY_SIZE; ///< Total size of Sampler and associated internal objects
-DALI_CORE_API extern const std::size_t SHADER_MEMORY_SIZE; ///< Total size of shader and associated internal objects
+DALI_CORE_API extern const std::size_t SAMPLER_MEMORY_SIZE; ///< Total size of Sampler and associated internal objects
+DALI_CORE_API extern const std::size_t SHADER_MEMORY_SIZE; ///< Total size of shader and associated internal objects
} // namespace Profiling
} // namespace Integration
#define DALI_INTEGRATION_RENDER_CONTROLLER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
/**
* Abstract interface for an object which controls rendering.
* This will be informed when Dali has new content to render.
class RenderController
{
protected:
-
/**
* Virtual protected destructor, no deletion through this interface
*/
- virtual ~RenderController() {}
+ virtual ~RenderController()
+ {
+ }
public:
-
/**
* Requests a future call to Dali::Integration::Core::Update().
* This is called when Dali has new content, typically in response to Actors/Animations being added.
* Multi-threading note: this method will be called from the main thread only.
* @param[in] forceUpdate true to update forcely.
*/
- virtual void RequestUpdate( bool forceUpdate ) = 0;
+ virtual void RequestUpdate(bool forceUpdate) = 0;
/**
* Requests a future call to Dali::Integration::Core::ProcessEvents(), when the application is idle.
* Multi-threading note: this method will be called from the main thread only.
* @param[in] forceProcess true to process events forcely.
*/
- virtual void RequestProcessEventsOnIdle( bool forceProcess ) = 0;
-
+ virtual void RequestProcessEventsOnIdle(bool forceProcess) = 0;
};
} // namespace Integration
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/integration-api/render-task-list-integ.h>
// INTERNAL INCLUDES
-#include <dali/internal/event/render-tasks/render-task-list-impl.h>
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
+#include <dali/internal/event/render-tasks/render-task-list-impl.h>
namespace Dali
{
-
namespace Integration
{
-
namespace RenderTaskList
{
-
Dali::RenderTaskList New()
{
Dali::Internal::RenderTaskListPtr renderTaskList = Dali::Internal::RenderTaskList::New();
- return Dali::RenderTaskList( renderTaskList.Get() );
+ return Dali::RenderTaskList(renderTaskList.Get());
}
-Dali::RenderTask CreateTask( Dali::RenderTaskList& taskList, Dali::Actor& sourceActor, Dali::CameraActor& cameraActor)
+Dali::RenderTask CreateTask(Dali::RenderTaskList& taskList, Dali::Actor& sourceActor, Dali::CameraActor& cameraActor)
{
- return RenderTask( GetImplementation(taskList).CreateTask( &GetImplementation( sourceActor), &GetImplementation(cameraActor) ).Get() );
+ return RenderTask(GetImplementation(taskList).CreateTask(&GetImplementation(sourceActor), &GetImplementation(cameraActor)).Get());
}
} // namespace RenderTaskList
#define DALI_INTEGRATION_RENDER_TASK_LIST_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
class Actor;
class CameraActor;
namespace Integration
{
-
namespace RenderTaskList
{
-
- /**
+/**
* @brief Helper function to create a new RenderTaskList object.
*
* A RenderTaskList is an ordered list of render tasks that describes
*
* @return A handle to a newly allocated RenderTaskList
*/
- DALI_CORE_API Dali::RenderTaskList New();
+DALI_CORE_API Dali::RenderTaskList New();
- /**
+/**
* @brief Helper function to create a new RenderTask.
*
* The created task will be appended to the list of render-tasks.
* @param[in] cameraActor The actor from which the scene is viewed for this render task.
* @return A valid handle to a new RenderTask
*/
- DALI_CORE_API Dali::RenderTask CreateTask( Dali::RenderTaskList& taskList, Dali::Actor& sourceActor, Dali::CameraActor& cameraActor);
+DALI_CORE_API Dali::RenderTask CreateTask(Dali::RenderTaskList& taskList, Dali::Actor& sourceActor, Dali::CameraActor& cameraActor);
} // namespace RenderTaskList
{
namespace ResourcePolicy
{
-
/**
* The discardable policy determines if a resource can be discarded.
* Discarded means that it can be released after uploading to GPU.
#define DALI_INTEGRATION_RESOURCE_TYPES_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-typedef Uint16Pair ImageDimensions;
+using ImageDimensions = Uint16Pair;
namespace Integration
{
-
/**
* BitmapResourceType describes a bitmap resource.
*/
* @param[in] orientationCorrection Whether to use bitmap metadata to rotate or
* flip the bitmap, e.g., from portrait to landscape.
*/
- BitmapResourceType( ImageDimensions size = ImageDimensions( 0, 0 ),
- FittingMode::Type scalingMode = FittingMode::DEFAULT,
- SamplingMode::Type samplingMode = SamplingMode::DEFAULT,
- bool orientationCorrection = true )
- : size( size ),
- scalingMode( scalingMode ),
- samplingMode( samplingMode ),
- orientationCorrection( orientationCorrection )
- {}
+ BitmapResourceType(ImageDimensions size = ImageDimensions(0, 0),
+ FittingMode::Type scalingMode = FittingMode::DEFAULT,
+ SamplingMode::Type samplingMode = SamplingMode::DEFAULT,
+ bool orientationCorrection = true)
+ : size(size),
+ scalingMode(scalingMode),
+ samplingMode(samplingMode),
+ orientationCorrection(orientationCorrection)
+ {
+ }
/**
* Destructor.
*/
~BitmapResourceType()
- {}
+ {
+ }
/**
* Attributes are copied from the request.
*/
- ImageDimensions size;
- FittingMode::Type scalingMode;
+ ImageDimensions size;
+ FittingMode::Type scalingMode;
SamplingMode::Type samplingMode;
- bool orientationCorrection;
+ bool orientationCorrection;
private:
-
// Undefined copy constructor.
BitmapResourceType(const BitmapResourceType& typePath);
// Undefined assignment operator.
BitmapResourceType& operator=(const BitmapResourceType& rhs);
-
};
} // namespace Integration
#include <dali/integration-api/scene.h>
// INTERNAL INCLUDES
+#include <dali/internal/event/common/scene-impl.h>
#include <dali/public-api/actors/layer.h>
#include <dali/public-api/render-tasks/render-task-list.h>
-#include <dali/internal/event/common/scene-impl.h>
namespace Dali
{
-
namespace Integration
{
-
-Scene Scene::New( Size size )
+Scene Scene::New(Size size)
{
- Internal::ScenePtr internal = Internal::Scene::New( size );
- return Scene( internal.Get() );
+ Internal::ScenePtr internal = Internal::Scene::New(size);
+ return Scene(internal.Get());
}
-Scene Scene::DownCast( BaseHandle handle )
+Scene Scene::DownCast(BaseHandle handle)
{
- return Scene( dynamic_cast<Dali::Internal::Scene*>( handle.GetObjectPtr()) );
+ return Scene(dynamic_cast<Dali::Internal::Scene*>(handle.GetObjectPtr()));
}
Scene::Scene()
{
}
-Scene::Scene( const Scene& handle )
-:BaseHandle(handle)
+Scene::Scene(const Scene& handle)
+: BaseHandle(handle)
{
}
-Scene::Scene( Internal::Scene* internal )
+Scene::Scene(Internal::Scene* internal)
: BaseHandle(internal)
{
}
-Scene& Scene::operator=( const Scene& rhs )
+Scene& Scene::operator=(const Scene& rhs)
{
BaseHandle::operator=(rhs);
return *this;
}
-void Scene::Add( Actor actor )
+void Scene::Add(Actor actor)
{
- GetImplementation(*this).Add( GetImplementation(actor) );
+ GetImplementation(*this).Add(GetImplementation(actor));
}
-void Scene::Remove( Actor actor )
+void Scene::Remove(Actor actor)
{
- GetImplementation(*this).Remove( GetImplementation(actor) );
+ GetImplementation(*this).Remove(GetImplementation(actor));
}
Size Scene::GetSize() const
return GetImplementation(*this).GetSize();
}
-void Scene::SetDpi( Vector2 dpi )
+void Scene::SetDpi(Vector2 dpi)
{
- GetImplementation(*this).SetDpi( dpi );
+ GetImplementation(*this).SetDpi(dpi);
}
Vector2 Scene::GetDpi() const
return GetImplementation(*this).GetDpi();
}
-void Scene::SetBackgroundColor( const Vector4& color )
+void Scene::SetBackgroundColor(const Vector4& color)
{
- GetImplementation(*this).SetBackgroundColor( color );
+ GetImplementation(*this).SetBackgroundColor(color);
}
Vector4 Scene::GetBackgroundColor() const
RenderTaskList Scene::GetRenderTaskList() const
{
- return RenderTaskList( &GetImplementation(*this).GetRenderTaskList() );
+ return RenderTaskList(&GetImplementation(*this).GetRenderTaskList());
}
Layer Scene::GetRootLayer() const
return GetImplementation(*this).GetLayerCount();
}
-Layer Scene::GetLayer( uint32_t depth ) const
+Layer Scene::GetLayer(uint32_t depth) const
{
- return GetImplementation(*this).GetLayer( depth );
+ return GetImplementation(*this).GetLayer(depth);
}
-void Scene::SurfaceResized( float width, float height )
+void Scene::SurfaceResized(float width, float height)
{
- GetImplementation( *this ).SurfaceResized( width, height );
+ GetImplementation(*this).SurfaceResized(width, height);
}
void Scene::SurfaceReplaced()
{
- GetImplementation( *this ).SurfaceReplaced();
+ GetImplementation(*this).SurfaceReplaced();
}
void Scene::Discard()
GetImplementation(*this).Discard();
}
-Integration::Scene Scene::Get( Actor actor )
+Integration::Scene Scene::Get(Actor actor)
{
- return Dali::Integration::Scene( &GetImplementation( actor ).GetScene() );
+ return Dali::Integration::Scene(&GetImplementation(actor).GetScene());
}
-void Scene::QueueEvent( const Integration::Event& event )
+void Scene::QueueEvent(const Integration::Event& event)
{
- GetImplementation(*this).QueueEvent( event );
+ GetImplementation(*this).QueueEvent(event);
}
void Scene::ProcessEvents()
GetImplementation(*this).ProcessEvents();
}
-void Scene::AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void Scene::AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
- GetImplementation( *this ).AddFrameRenderedCallback( std::move( callback ), frameId );
+ GetImplementation(*this).AddFrameRenderedCallback(std::move(callback), frameId);
}
-void Scene::AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId )
+void Scene::AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId)
{
- GetImplementation( *this ).AddFramePresentedCallback( std::move( callback ), frameId );
+ GetImplementation(*this).AddFramePresentedCallback(std::move(callback), frameId);
}
-void Scene::GetFrameRenderedCallback( FrameCallbackContainer& callbacks )
+void Scene::GetFrameRenderedCallback(FrameCallbackContainer& callbacks)
{
- GetImplementation( *this ).GetFrameRenderedCallback( callbacks );
+ GetImplementation(*this).GetFrameRenderedCallback(callbacks);
}
-void Scene::GetFramePresentedCallback( FrameCallbackContainer& callbacks )
+void Scene::GetFramePresentedCallback(FrameCallbackContainer& callbacks)
{
- GetImplementation( *this ).GetFramePresentedCallback( callbacks );
+ GetImplementation(*this).GetFramePresentedCallback(callbacks);
}
Scene::EventProcessingFinishedSignalType& Scene::EventProcessingFinishedSignal()
return GetImplementation(*this).WheelEventSignal();
}
-} // Integration
+} // namespace Integration
-} // Dali
+} // namespace Dali
#include <memory>
// INTERNAL INCLUDES
-#include <dali/public-api/object/handle.h>
+#include <dali/public-api/common/vector-wrapper.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/object/handle.h>
namespace Dali
{
-
class Actor;
class KeyEvent;
class Layer;
namespace Internal DALI_INTERNAL
{
- class Scene;
+class Scene;
}
namespace Integration
{
-
struct Event;
/**
class DALI_CORE_API Scene : public BaseHandle
{
public:
- typedef Signal< void () > EventProcessingFinishedSignalType; ///< Event Processing finished signal type
- typedef Signal< void (const Dali::KeyEvent&) > KeyEventSignalType; ///< Key event signal type
- typedef Signal< bool (const Dali::KeyEvent&) > KeyEventGeneratedSignalType; ///< key event generated signal type
- typedef Signal< void (const Dali::TouchEvent&) > TouchEventSignalType; ///< Touch signal type
- typedef Signal< void (const Dali::WheelEvent&) > WheelEventSignalType; ///< WheelEvent signal type
+ using EventProcessingFinishedSignalType = Signal<void()>; ///< Event Processing finished signal type
+ using KeyEventSignalType = Signal<void(const Dali::KeyEvent&)>; ///< Key event signal type
+ using KeyEventGeneratedSignalType = Signal<bool(const Dali::KeyEvent&)>; ///< key event generated signal type
+ using TouchEventSignalType = Signal<void(const Dali::TouchEvent&)>; ///< Touch signal type
+ using WheelEventSignalType = Signal<void(const Dali::WheelEvent&)>; ///< WheelEvent signal type
- using FrameCallbackContainer = std::vector< std::pair< std::unique_ptr< CallbackBase >, int32_t > >;
+ using FrameCallbackContainer = std::vector<std::pair<std::unique_ptr<CallbackBase>, int32_t> >;
/**
* @brief Create an initialized Scene handle.
*
* @return a handle to a newly allocated Dali resource.
*/
- static Scene New( Size size );
+ static Scene New(Size size);
/**
* @brief Downcast an Object handle to Scene handle.
* @param[in] handle to An object
* @return handle to a Scene object or an uninitialized handle
*/
- static Scene DownCast( BaseHandle handle );
+ static Scene DownCast(BaseHandle handle);
/**
* @brief Create an uninitialized Scene handle.
* Sets horizontal and vertical pixels per inch value that is used by the display
* @param[in] dpi Horizontal and vertical dpi value
*/
- void SetDpi( Vector2 dpi );
+ void SetDpi(Vector2 dpi);
/**
* @brief Retrieves the DPI of the display device to which the scene is connected.
*
* @param[in] color The new background color
*/
- void SetBackgroundColor( const Vector4& color );
+ void SetBackgroundColor(const Vector4& color);
/**
* @brief Gets the background color of the render　surface.
* @return The layer found at the given depth
* @pre Depth is less than layer count; see GetLayerCount().
*/
- Layer GetLayer( uint32_t depth ) const;
+ Layer GetLayer(uint32_t depth) const;
/**
* @brief Informs the scene that the set surface has been resized.
* @param[in] width The new width of the set surface
* @param[in] height The new height of the set surface
*/
- void SurfaceResized( float width, float height );
+ void SurfaceResized(float width, float height);
/**
* @brief Informs the scene that the surface has been replaced.
* @brief Retrieve the Scene that the given actor belongs to.
* @return The Scene.
*/
- static Integration::Scene Get( Actor actor );
+ static Integration::Scene Get(Actor actor);
/**
* This function is called when an event is queued.
* @param[in] event A event to queue.
*/
- void QueueEvent( const Integration::Event& event );
+ void QueueEvent(const Integration::Event& event);
/**
* This function is called by Core when events are processed.
*
* @note Ownership of the callback is passed onto this class.
*/
- void AddFrameRenderedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+ void AddFrameRenderedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @brief Adds a callback that is called when the frame is displayed on the display.
*
* @note Ownership of the callback is passed onto this class.
*/
- void AddFramePresentedCallback( std::unique_ptr< CallbackBase > callback, int32_t frameId );
+ void AddFramePresentedCallback(std::unique_ptr<CallbackBase> callback, int32_t frameId);
/**
* @brief Gets the callback list that is called when the frame rendering is done by the graphics driver.
*
* @note This is called in the update thread.
*/
- void GetFrameRenderedCallback( FrameCallbackContainer& callbacks );
+ void GetFrameRenderedCallback(FrameCallbackContainer& callbacks);
/**
* @brief Gets the callback list that is called when the frame is displayed on the display.
*
* @note This is called in the update thread.
*/
- void GetFramePresentedCallback( FrameCallbackContainer& callbacks );
+ void GetFramePresentedCallback(FrameCallbackContainer& callbacks);
/**
* @brief This signal is emitted just after the event processing is finished.
WheelEventSignalType& WheelEventSignal();
public: // Not intended for application developers
-
/**
* @brief This constructor is used by Dali::New() methods.
*
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/integration-api/trace.h>
// EXTERNAL INCLUDES
-#include <list>
#include <cstdarg>
+#include <list>
namespace Dali
{
-
namespace Integration
{
-
namespace Trace
{
-
thread_local LogContextFunction gThreadLocalLogContextFunction = nullptr;
-void InstallLogContextFunction( const LogContextFunction& logContextFunction )
+void InstallLogContextFunction(const LogContextFunction& logContextFunction)
{
gThreadLocalLogContextFunction = logContextFunction;
}
-void LogContext( bool start, const char* tag )
+void LogContext(bool start, const char* tag)
{
- if ( !gThreadLocalLogContextFunction )
+ if(!gThreadLocalLogContextFunction)
{
return;
}
- gThreadLocalLogContextFunction( start, tag );
+ gThreadLocalLogContextFunction(start, tag);
}
#ifdef TRACE_ENABLED
namespace
{
- static FilterList* GetActiveFilters()
- {
- static FilterList* activeFilters = new FilterList;
- return activeFilters;
- }
+static FilterList* GetActiveFilters()
+{
+ static FilterList* activeFilters = new FilterList;
+ return activeFilters;
}
+} // namespace
-Filter* Filter::New( bool trace, const char * environmentVariableName )
+Filter* Filter::New(bool trace, const char* environmentVariableName)
{
- char * environmentVariableValue = getenv( environmentVariableName );
- if ( environmentVariableValue )
+ char* environmentVariableValue = getenv(environmentVariableName);
+ if(environmentVariableValue)
{
- char envTraceString( 0 );
- sscanf( environmentVariableValue, "%c", &envTraceString );
+ char envTraceString(0);
+ sscanf(environmentVariableValue, "%c", &envTraceString);
// Just use 'f' and 't' as it's faster than doing full string comparisons
- if ( envTraceString == 't' )
+ if(envTraceString == 't')
{
trace = true;
}
- else if ( envTraceString == 'f' )
+ else if(envTraceString == 'f')
{
trace = false;
}
}
- Filter* filter = new Filter( trace );
- GetActiveFilters()->push_back( filter );
+ Filter* filter = new Filter(trace);
+ GetActiveFilters()->push_back(filter);
return filter;
}
*/
void Filter::EnableGlobalTrace()
{
- for( FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++ )
+ for(FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++)
{
(*iter)->EnableTrace();
}
*/
void Filter::DisableGlobalTrace()
{
- for( FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++ )
+ for(FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++)
{
(*iter)->DisableTrace();
}
/**
* Begin Trace
*/
-void Filter::BeginTrace( const char* tagName )
+void Filter::BeginTrace(const char* tagName)
{
- Dali::Integration::Trace::LogContext( true, tagName );
+ Dali::Integration::Trace::LogContext(true, tagName);
}
/**
* End Trace
*/
-void Filter::EndTrace( const char* tagName )
+void Filter::EndTrace(const char* tagName)
{
- Dali::Integration::Trace::LogContext( false, tagName );
+ Dali::Integration::Trace::LogContext(false, tagName);
}
/**
* Tracer Constructor
*/
-Tracer::Tracer( Filter* filter, const char* tag )
-: mTag( tag ),
- mFilter( filter )
+Tracer::Tracer(Filter* filter, const char* tag)
+: mTag(tag),
+ mFilter(filter)
{
- if( mFilter && mFilter->IsTraceEnabled() )
+ if(mFilter && mFilter->IsTraceEnabled())
{
- mFilter->BeginTrace( mTag );
+ mFilter->BeginTrace(mTag);
}
}
*/
Tracer::~Tracer()
{
- if( mFilter && mFilter->IsTraceEnabled() )
+ if(mFilter && mFilter->IsTraceEnabled())
{
- mFilter->EndTrace( mTag );
+ mFilter->EndTrace(mTag);
}
}
#endif //TRACE_ENABLED
-} // Trace
+} // namespace Trace
-} // Integration
+} // namespace Integration
-} // Dali
+} // namespace Dali
#define DALI_INTEGRATION_TRACE_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace Integration
{
-
namespace Trace
{
-
/**
* Used by tracing macros to log a context message
* @param start a bool to indicate start (true) or end (false) of the tracing / logging
* @param tag a unique event tag name
*/
-DALI_CORE_API void LogContext( bool start, const char* tag );
+DALI_CORE_API void LogContext(bool start, const char* tag);
/**
* typedef for the LogContextFunction function.
*/
-typedef void ( *LogContextFunction )( bool start, const char* tag );
+using LogContextFunction = void (*)(bool, const char*);
/**
* A LogContextFunction function has to be installed for every thread that wants to use tracing.
* The LogContextFunction function can be different for each thread.
* @param LogContextFunction the Log Context function to install
*/
-DALI_CORE_API void InstallLogContextFunction( const LogContextFunction& logContextFunction );
+DALI_CORE_API void InstallLogContextFunction(const LogContextFunction& logContextFunction);
/********************************************************************************
* Filter *
class DALI_CORE_API Filter
{
public:
-
/**
* Test if trace is enabled for this filter.
* @return true if trace is enabled;
*/
- inline bool IsTraceEnabled() { return mTraceEnabled; }
+ inline bool IsTraceEnabled()
+ {
+ return mTraceEnabled;
+ }
/**
* Enable tracing on this filter.
*/
- inline void EnableTrace() { mTraceEnabled = true; }
+ inline void EnableTrace()
+ {
+ mTraceEnabled = true;
+ }
/**
* Disable tracing on this filter.
*/
- inline void DisableTrace() { mTraceEnabled = false; }
+ inline void DisableTrace()
+ {
+ mTraceEnabled = false;
+ }
/**
* Create a new filter whose trace can be modified through the use of an environment variable.
* TRACE_ENV=0 dali-demo // Trace OFF
* @endcode
*/
- static Filter* New( bool trace, const char * environmentVariableName );
+ static Filter* New(bool trace, const char* environmentVariableName);
/**
* Begin trace.
* @param[in] tagName - a unique event tag name.
*/
- void BeginTrace( const char* tagName );
+ void BeginTrace(const char* tagName);
/**
* End trace.
* @param[in] tagName - a unique event tag name.
*/
- void EndTrace( const char* tagName );
+ void EndTrace(const char* tagName);
/**
* Enable trace on all filters.
static void DisableGlobalTrace();
private:
-
/**
* Constructor.
* @param[in] trace - whether this filter allows tracing.
*/
- Filter( bool trace ) : mTraceEnabled( trace ) {}
+ Filter(bool trace)
+ : mTraceEnabled(trace)
+ {
+ }
private:
bool mTraceEnabled;
class DALI_CORE_API Tracer final
{
public:
- Tracer( Filter* filter, const char* tag );
+ Tracer(Filter* filter, const char* tag);
~Tracer();
public:
const char* mTag;
- Filter* mFilter;
+ Filter* mFilter;
};
/**
* Initialization of trace filter
* @ref Filter::New
*/
-#define DALI_INIT_TRACE_FILTER( name, environmentVariableName, enable ) \
-namespace \
-{ \
- Dali::Integration::Trace::Filter* name = Dali::Integration::Trace::Filter::New( enable, #environmentVariableName ); \
-}
+#define DALI_INIT_TRACE_FILTER(name, environmentVariableName, enable) \
+ namespace \
+ { \
+ Dali::Integration::Trace::Filter* name = Dali::Integration::Trace::Filter::New(enable, #environmentVariableName); \
+ }
/**
* Start of tracing
*/
-#define DALI_TRACE_BEGIN( filter, tag ) \
- if( filter && filter->IsTraceEnabled() ) { filter->BeginTrace( tag ); }
+#define DALI_TRACE_BEGIN(filter, tag) \
+ if(filter && filter->IsTraceEnabled()) \
+ { \
+ filter->BeginTrace(tag); \
+ }
/**
* End of tracing
*/
-#define DALI_TRACE_END( filter, tag ) \
- if( filter && filter->IsTraceEnabled() ) { filter->EndTrace( tag ); }
+#define DALI_TRACE_END(filter, tag) \
+ if(filter && filter->IsTraceEnabled()) \
+ { \
+ filter->EndTrace(tag); \
+ }
/**
* Used for function tracing. It logs tracing of the fuction from start to end.
*/
-#define DALI_TRACE_FUNCTION( filter ) \
- Dali::Integration::Trace::Tracer logTraceFunction( filter, ASSERT_LOCATION );
+#define DALI_TRACE_FUNCTION(filter) \
+ Dali::Integration::Trace::Tracer logTraceFunction(filter, ASSERT_LOCATION);
/**
* Used for scope tracing. It logs tracing around a scope.
*/
-#define DALI_TRACE_SCOPE( filter, tag ) \
- Dali::Integration::Trace::Tracer logTracerScope( filter, tag );
+#define DALI_TRACE_SCOPE(filter, tag) \
+ Dali::Integration::Trace::Tracer logTracerScope(filter, tag);
#else // TRACE_ENABLED
-#define DALI_INIT_TRACE_FILTER( name, tag, enable )
-#define DALI_TRACE_BEGIN( filter, tag )
-#define DALI_TRACE_END( filter, tag )
-#define DALI_TRACE_FUNCTION( filter )
-#define DALI_TRACE_SCOPE( filter, tag )
+#define DALI_INIT_TRACE_FILTER(name, tag, enable)
+#define DALI_TRACE_BEGIN(filter, tag)
+#define DALI_TRACE_END(filter, tag)
+#define DALI_TRACE_FUNCTION(filter)
+#define DALI_TRACE_SCOPE(filter, tag)
#endif
-} // Trace
+} // namespace Trace
-} // Integration
+} // namespace Integration
-} // Dali
+} // namespace Dali
#endif // DALI_INTEGRATION_TRACE_H
BlendingOptions::BlendingOptions()
: mBitmask( 0u ),
- mBlendColor( NULL )
+ mBlendColor( nullptr )
{
SetBlendFunc( BlendFactor::SRC_ALPHA, BlendFactor::ONE_MINUS_SRC_ALPHA,
BlendFactor::ONE, BlendFactor::ONE_MINUS_SRC_ALPHA );
{
if( Color::TRANSPARENT == color )
{
- mBlendColor = NULL;
+ mBlendColor = nullptr;
}
else
{
namespace Internal
{
-
-typedef uint32_t BufferIndex;
+using BufferIndex = uint32_t;
} // namespace Internal
/**
* Destructor
*/
- ~Core();
+ ~Core() override;
/**
* @copydoc Dali::Integration::Core::Initialize()
* @param size The size of the memory block to allocate in bytes. Must be non-zero.
*/
Block( SizeType size )
- : nextBlock( NULL )
+ : nextBlock( nullptr )
#ifdef DEBUG_ENABLED
,mBlockSize( size )
#endif
mCurrentBlock( &mMemoryBlocks ),
mCurrentBlockCapacity( initialCapacity ),
mCurrentBlockSize( 0 ),
- mDeletedObjects( NULL )
+ mDeletedObjects( nullptr )
{
// We need enough room to store the deleted list in the data
DALI_ASSERT_DEBUG( mFixedSize >= sizeof( void* ) );
class FixedSizeMemoryPool
{
public:
-
- typedef uint32_t SizeType;
+ using SizeType = uint32_t;
public:
* ScalingMode, but all other filter modes do if the desired dimensions are
* `<=` the raw dimensions of the image file.
*/
- typedef Dali::SamplingMode::Type FilterMode;
+ using FilterMode = Dali::SamplingMode::Type;
static const ImageAttributes DEFAULT_ATTRIBUTES; ///< Default attributes have no size
#define DALI_INTERNAL_CONSTANTS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
{
// Constants used by renderers and actors to determine if something is visible.
-extern const float FULLY_OPAQUE; ///< Alpha values must drop below this, before an object is considered to be transparent.
-extern const float FULLY_TRANSPARENT; ///< Alpha values must rise above this, before an object is considered to be visible.
+static constexpr float FULLY_OPAQUE(0.99f); ///< Alpha values must drop below this, before an object is considered to be transparent.
+static constexpr float FULLY_TRANSPARENT(0.01f); ///< Alpha values must rise above this, before an object is considered to be visible.
} // namespace Internal
* @brief Constructor
*/
MemoryPoolObjectAllocator()
- : mPool( NULL )
+ : mPool( nullptr )
{
ResetMemoryPool();
}
MessageBuffer::MessageBuffer( std::size_t initialCapacity )
: mInitialCapacity( initialCapacity / WORD_SIZE ),
- mData( NULL ),
- mNextSlot( NULL ),
+ mData( nullptr ),
+ mNextSlot( nullptr ),
mCapacity( 0 ),
mSize( 0 )
{
return Iterator( mData );
}
- return Iterator( NULL );
+ return Iterator( nullptr );
}
void MessageBuffer::Reset()
{
mData = reinterpret_cast<WordType*>( malloc( newCapacity * WORD_SIZE ) );
}
- DALI_ASSERT_ALWAYS( NULL != mData );
+ DALI_ASSERT_ALWAYS( nullptr != mData );
mCapacity = newCapacity;
mNextSlot = mData + mSize;
: mCurrent(current),
mMessageSize(0)
{
- if( NULL != mCurrent )
+ if( nullptr != mCurrent )
{
// The first word is the size of the following object
mMessageSize = *mCurrent++;
class MessageBuffer
{
public:
- typedef std::ptrdiff_t WordType;
+ using WordType = std::ptrdiff_t;
/**
* Create a new MessageBuffer
// Inlined for performance
WordType* Get()
{
- return ( 0 != mMessageSize ) ? mCurrent : NULL;
+ return ( 0 != mMessageSize ) ? mCurrent : nullptr;
}
// Inlined for performance
class Message : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)();
+ using MemberFunction = void ( T::* )();
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~Message()
+ ~Message() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)();
}
class MessageValue1 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)( typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue1()
+ ~MessageValue1() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1 );
}
class MessageValue2 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue2()
+ ~MessageValue2() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2 );
}
class MessageValue3 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue3()
+ ~MessageValue3() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3 );
}
class MessageValue4 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue4()
+ ~MessageValue4() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4 );
}
class MessageValue5 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType,
- typename ParameterType< P5 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue5()
+ ~MessageValue5() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4, param5 );
}
class MessageValue6 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- typename ParameterType< P1 >::PassingType,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType,
- typename ParameterType< P5 >::PassingType,
- typename ParameterType< P6 >::PassingType );
+ using MemberFunction = void ( T::* )( typename ParameterType<P1>::PassingType, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType, typename ParameterType<P6>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageValue6()
+ ~MessageValue6() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
(object->*memberFunction)( param1, param2, param3, param4, param5, param6 );
}
class MessageDoubleBuffered0 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)( BufferIndex );
+ using MemberFunction = void ( T::* )( BufferIndex );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered0()
+ ~MessageDoubleBuffered0() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex );
}
class MessageDoubleBuffered1 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered1()
+ ~MessageDoubleBuffered1() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param );
}
class MessageDoubleBuffered2 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered2()
+ ~MessageDoubleBuffered2() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3 );
}
class MessageDoubleBuffered3 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered3()
+ ~MessageDoubleBuffered3() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3, param4 );
}
class MessageDoubleBuffered4 : public MessageBase
{
public:
-
- typedef void(T::*MemberFunction)(
- BufferIndex,
- typename ParameterType< P2 >::PassingType,
- typename ParameterType< P3 >::PassingType,
- typename ParameterType< P4 >::PassingType,
- typename ParameterType< P5 >::PassingType );
+ using MemberFunction = void ( T::* )( BufferIndex, typename ParameterType<P2>::PassingType, typename ParameterType<P3>::PassingType, typename ParameterType<P4>::PassingType, typename ParameterType<P5>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~MessageDoubleBuffered4()
+ ~MessageDoubleBuffered4() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex bufferIndex )
+ void Process( BufferIndex bufferIndex ) override
{
(object->*memberFunction)( bufferIndex, param2, param3, param4, param5 );
}
/**
* Pointer-to-member type. Objects can be implicitly converted to this for validity checks.
*/
- typedef void (OwnerPointer::*BooleanType)() const;
+ using BooleanType = void ( OwnerPointer<T>::* )() const;
/**
* Converts an object handle to a BooleanType.
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* ShaderData class.
* Protected Destructor
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~ShaderData()
+ ~ShaderData() override
{
// vector releases its data
}
namespace Internal
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* Abstract interface for passing a ShaderData object towards being saved.
template <typename Type>
struct BasicType
{
- typedef Type HolderType;
- typedef Type PassingType;
+ using HolderType = Type;
+ using PassingType = Type;
};
// For complex types that are copied into the message,
template <typename Type>
struct ComplexType
{
- typedef Type HolderType;
- typedef const Type& PassingType;
+ using HolderType = Type;
+ using PassingType = const Type&;
};
// For complex types that are owned by the message,
template <typename Type>
struct OwnedType
{
- typedef OwnerPointer<Type> HolderType;
- typedef OwnerPointer<Type>& PassingType;
+ using HolderType = OwnerPointer<Type>;
+ using PassingType = OwnerPointer<Type>&;
};
class CustomActor;
class Layer;
-typedef IntrusivePtr<Actor> ActorPtr;
-typedef IntrusivePtr<CameraActor> CameraActorPtr;
-typedef IntrusivePtr<CustomActor> CustomActorPtr;
-typedef IntrusivePtr<Layer> LayerPtr;
+using ActorPtr = IntrusivePtr<Actor>;
+using CameraActorPtr = IntrusivePtr<CameraActor>;
+using CustomActorPtr = IntrusivePtr<CustomActor>;
+using LayerPtr = IntrusivePtr<Layer>;
} // namespace Internal
#include <dali/devel-api/actors/layer-devel.h>
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
-#include <dali/public-api/events/touch-event.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/radian.h>
#include <dali/public-api/object/type-registry.h>
#include <dali/devel-api/actors/actor-devel.h>
-#include <dali/devel-api/scripting/scripting.h>
-#include <dali/internal/common/internal-constants.h>
+#include <dali/internal/event/actors/actor-property-handler.h>
+#include <dali/internal/event/actors/actor-relayouter.h>
#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
#include <dali/internal/event/common/type-info-impl.h>
#include <dali/internal/event/common/scene-impl.h>
#include <dali/internal/event/common/thread-local-storage.h>
-#include <dali/internal/event/animation/constraint-impl.h>
#include <dali/internal/event/common/projection.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
-#include <dali/internal/update/common/animatable-property.h>
#include <dali/internal/update/nodes/node-messages.h>
-#include <dali/internal/update/nodes/node-declarations.h>
-#include <dali/internal/update/animation/scene-graph-constraint.h>
#include <dali/internal/event/events/actor-gesture-data.h>
-#include <dali/internal/common/message.h>
#include <dali/integration-api/debug.h>
using Dali::Internal::SceneGraph::Node;
namespace Internal
{
-namespace
-{
-/// Using a function because of library initialisation order. Vector3::ONE may not have been initialised yet.
-inline const Vector3& GetDefaultSizeModeFactor()
-{
- return Vector3::ONE;
-}
-
-/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
-inline const Vector2& GetDefaultPreferredSize()
-{
- return Vector2::ZERO;
-}
-
-/// Using a function because of library initialisation order. Vector2::ZERO may not have been initialised yet.
-inline const Vector2& GetDefaultDimensionPadding()
-{
- return Vector2::ZERO;
-}
-
-const SizeScalePolicy::Type DEFAULT_SIZE_SCALE_POLICY = SizeScalePolicy::USE_SIZE_SET;
-
-} // unnamed namespace
-
-/**
- * Struct to collect relayout variables
- */
-struct Actor::RelayoutData
-{
- RelayoutData()
- : sizeModeFactor( GetDefaultSizeModeFactor() ), preferredSize( GetDefaultPreferredSize() ), sizeSetPolicy( DEFAULT_SIZE_SCALE_POLICY ), relayoutEnabled( false ), insideRelayout( false )
- {
- // Set size negotiation defaults
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- resizePolicies[ i ] = ResizePolicy::DEFAULT;
- useAssignedSize[ i ] = false;
- negotiatedDimensions[ i ] = 0.0f;
- dimensionNegotiated[ i ] = false;
- dimensionDirty[ i ] = false;
- dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
- dimensionPadding[ i ] = GetDefaultDimensionPadding();
- minimumSize[ i ] = 0.0f;
- maximumSize[ i ] = FLT_MAX;
- }
- }
-
- ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ]; ///< Resize policies
- bool useAssignedSize[ Dimension::DIMENSION_COUNT ]; ///< The flag to specify whether the size should be assigned to the actor
-
- Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ]; ///< A list of dimension dependencies
-
- Vector2 dimensionPadding[ Dimension::DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
-
- float negotiatedDimensions[ Dimension::DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
-
- float minimumSize[ Dimension::DIMENSION_COUNT ]; ///< The minimum size an actor can be
- float maximumSize[ Dimension::DIMENSION_COUNT ]; ///< The maximum size an actor can be
-
- bool dimensionNegotiated[ Dimension::DIMENSION_COUNT ]; ///< Has the dimension been negotiated
- bool dimensionDirty[ Dimension::DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
-
- Vector3 sizeModeFactor; ///< Factor of size used for certain SizeModes
-
- Vector2 preferredSize; ///< The preferred size of the actor
-
- SizeScalePolicy::Type sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
-
- bool relayoutEnabled :1; ///< Flag to specify if this actor should be included in size negotiation or not (defaults to true)
- bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set
-};
-
namespace // unnamed namespace
{
TypeAction a1( mType, ACTION_SHOW, &Actor::DoAction );
TypeAction a2( mType, ACTION_HIDE, &Actor::DoAction );
-struct AnchorValue
-{
- const char* name;
- const Vector3& value;
-};
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( AnchorValue, ANCHOR_CONSTANT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_LEFT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_RIGHT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_LEFT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_RIGHT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_LEFT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_CENTER )
-DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_RIGHT )
-DALI_ENUM_TO_STRING_TABLE_END( ANCHOR_CONSTANT )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( COLOR_MODE )
-DALI_ENUM_TO_STRING( USE_OWN_COLOR )
-DALI_ENUM_TO_STRING( USE_PARENT_COLOR )
-DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_COLOR )
-DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_ALPHA )
-DALI_ENUM_TO_STRING_TABLE_END( COLOR_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( DRAW_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, NORMAL )
-DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, OVERLAY_2D )
-DALI_ENUM_TO_STRING_TABLE_END( DRAW_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( RESIZE_POLICY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIXED )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_NATURAL_SIZE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FILL_TO_PARENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_RELATIVE_TO_PARENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_FIXED_OFFSET_FROM_PARENT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIT_TO_CHILDREN )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, DIMENSION_DEPENDENCY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_ASSIGNED_SIZE )
-DALI_ENUM_TO_STRING_TABLE_END( RESIZE_POLICY )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( SIZE_SCALE_POLICY )
-DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, USE_SIZE_SET )
-DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FIT_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FILL_WITH_ASPECT_RATIO )
-DALI_ENUM_TO_STRING_TABLE_END( SIZE_SCALE_POLICY )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED )
-DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN )
-DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE )
-
-DALI_ENUM_TO_STRING_TABLE_BEGIN( LAYOUT_DIRECTION )
-DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, LEFT_TO_RIGHT )
-DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, RIGHT_TO_LEFT )
-DALI_ENUM_TO_STRING_TABLE_END( LAYOUT_DIRECTION )
-
-bool GetAnchorPointConstant( const std::string& value, Vector3& anchor )
-{
- for( uint32_t i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
- {
- uint32_t sizeIgnored = 0;
- if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
- {
- anchor = ANCHOR_CONSTANT_TABLE[ i ].value;
- return true;
- }
- }
- return false;
-}
-
-inline bool GetParentOriginConstant( const std::string& value, Vector3& parentOrigin )
-{
- // Values are the same so just use the same table as anchor-point
- return GetAnchorPointConstant( value, parentOrigin );
-}
-
/**
* @brief Extract a given dimension from a Vector2
*
* @param[in] dimension The dimension to extract
* @return Return the value for the dimension
*/
-float GetDimensionValue( const Vector2& values, Dimension::Type dimension )
+constexpr float GetDimensionValue( const Vector2& values, Dimension::Type dimension )
{
switch( dimension )
{
if( actor->GetChildCount() > 0 )
{
- ActorContainer& children = actor->GetChildrenInternal();
- for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+ for( ActorPtr& child : actor->GetChildrenInternal() )
{
- EmitVisibilityChangedSignalRecursively( *iter, visible, DevelActor::VisibilityChange::PARENT );
+ EmitVisibilityChangedSignalRecursively( child, visible, DevelActor::VisibilityChange::PARENT );
}
}
}
}
+/// Helper for emitting a signal
+template<typename Signal, typename Event>
+bool EmitConsumingSignal( Actor& actor, Signal& signal, const Event& event )
+{
+ bool consumed = false;
+
+ if( !signal.Empty() )
+ {
+ Dali::Actor handle( &actor );
+ consumed = signal.Emit( handle, event );
+ }
+
+ return consumed;
+}
+
+/// Helper for emitting signals with multiple parameters
+template<typename Signal, typename... Param>
+void EmitSignal( Actor& actor, Signal& signal, Param... params)
+{
+ if( !signal.Empty() )
+ {
+ Dali::Actor handle( &actor );
+ signal.Emit( handle, params... );
+ }
+}
+
+bool ScreenToLocalInternal(
+ const Matrix& viewMatrix,
+ const Matrix& projectionMatrix,
+ const Matrix& worldMatrix,
+ const Viewport& viewport,
+ const Vector3& currentSize,
+ float& localX,
+ float& localY,
+ float screenX,
+ float screenY )
+{
+ // Get the ModelView matrix
+ Matrix modelView;
+ Matrix::Multiply( modelView, worldMatrix, viewMatrix );
+
+ // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
+ Matrix invertedMvp( false/*don't init*/);
+ Matrix::Multiply( invertedMvp, modelView, projectionMatrix );
+ bool success = invertedMvp.Invert();
+
+ // Convert to GL coordinates
+ Vector4 screenPos( screenX - static_cast<float>( viewport.x ), static_cast<float>( viewport.height ) - screenY - static_cast<float>( viewport.y ), 0.f, 1.f );
+
+ Vector4 nearPos;
+ if( success )
+ {
+ success = Unproject( screenPos, invertedMvp, static_cast<float>( viewport.width ), static_cast<float>( viewport.height ), nearPos );
+ }
+
+ Vector4 farPos;
+ if( success )
+ {
+ screenPos.z = 1.0f;
+ success = Unproject( screenPos, invertedMvp, static_cast<float>( viewport.width ), static_cast<float>( viewport.height ), farPos );
+ }
+
+ if( success )
+ {
+ Vector4 local;
+ if( XyPlaneIntersect( nearPos, farPos, local ) )
+ {
+ Vector3 size = currentSize;
+ localX = local.x + size.x * 0.5f;
+ localY = local.y + size.y * 0.5f;
+ }
+ else
+ {
+ success = false;
+ }
+ }
+
+ return success;
+}
+
} // unnamed namespace
ActorPtr Actor::New()
return node;
}
-const std::string& Actor::GetName() const
-{
- return mName;
-}
-
void Actor::SetName( const std::string& name )
{
mName = name;
return GetNode().GetId();
}
-bool Actor::OnScene() const
-{
- return mIsOnScene;
-}
-
Dali::Layer Actor::GetLayer()
{
Dali::Layer layer;
}
// Find the immediate Layer parent
- for( Actor* parent = mParent; !layer && parent != NULL; parent = parent->GetParent() )
+ for( Actor* parent = mParent; !layer && parent != nullptr; parent = parent->GetParent() )
{
if( parent->IsLayer() )
{
mChildren->erase( iter );
DALI_ASSERT_DEBUG( actor->GetParent() == this );
- actor->SetParent( NULL );
+ actor->SetParent( nullptr );
break;
}
uint32_t Actor::GetChildCount() const
{
- return ( NULL != mChildren ) ? static_cast<uint32_t>( mChildren->size() ) : 0; // only 4,294,967,295 children per actor
+ return ( nullptr != mChildren ) ? static_cast<uint32_t>( mChildren->size() ) : 0; // only 4,294,967,295 children per actor
}
ActorPtr Actor::GetChildAt( uint32_t index ) const
ActorPtr Actor::FindChildByName( const std::string& actorName )
{
- ActorPtr child = 0;
+ ActorPtr child = nullptr;
if( actorName == mName )
{
child = this;
ActorPtr Actor::FindChildById( const uint32_t id )
{
- ActorPtr child = 0;
+ ActorPtr child = nullptr;
if( id == GetId() )
{
child = this;
}
}
-void Actor::SetParentOriginX( float x )
-{
- const Vector3& current = GetCurrentParentOrigin();
-
- SetParentOrigin( Vector3( x, current.y, current.z ) );
-}
-
-void Actor::SetParentOriginY( float y )
-{
- const Vector3& current = GetCurrentParentOrigin();
-
- SetParentOrigin( Vector3( current.x, y, current.z ) );
-}
-
-void Actor::SetParentOriginZ( float z )
-{
- const Vector3& current = GetCurrentParentOrigin();
-
- SetParentOrigin( Vector3( current.x, current.y, z ) );
-}
-
const Vector3& Actor::GetCurrentParentOrigin() const
{
// Cached for event-thread access
}
}
-void Actor::SetAnchorPointX( float x )
-{
- const Vector3& current = GetCurrentAnchorPoint();
-
- SetAnchorPoint( Vector3( x, current.y, current.z ) );
-}
-
-void Actor::SetAnchorPointY( float y )
-{
- const Vector3& current = GetCurrentAnchorPoint();
-
- SetAnchorPoint( Vector3( current.x, y, current.z ) );
-}
-
-void Actor::SetAnchorPointZ( float z )
-{
- const Vector3& current = GetCurrentAnchorPoint();
-
- SetAnchorPoint( Vector3( current.x, current.y, z ) );
-}
-
const Vector3& Actor::GetCurrentAnchorPoint() const
{
// Cached for event-thread access
return GetNode().GetPosition(GetEventThreadServices().GetEventBufferIndex());
}
-const Vector3& Actor::GetTargetPosition() const
-{
- return mTargetPosition;
-}
-
const Vector3& Actor::GetCurrentWorldPosition() const
{
// node is being used in a separate thread; copy the value from the previous update
}
}
-bool Actor::IsPositionInherited() const
-{
- return mInheritPosition;
-}
-
void Actor::SetOrientation( const Radian& angle, const Vector3& axis )
{
Vector3 normalizedAxis( axis.x, axis.y, axis.z );
}
}
-bool Actor::IsScaleInherited() const
-{
- return mInheritScale;
-}
-
Matrix Actor::GetCurrentWorldMatrix() const
{
return GetNode().GetWorldMatrix(0);
return GetNode().GetOpacity(GetEventThreadServices().GetEventBufferIndex());
}
-ClippingMode::Type Actor::GetClippingMode() const
-{
- return mClippingMode;
-}
-
-uint32_t Actor::GetSortingDepth()
-{
- return mSortedDepth;
-}
-
const Vector4& Actor::GetCurrentWorldColor() const
{
return GetNode().GetWorldColor( GetEventThreadServices().GetEventBufferIndex() );
}
}
-bool Actor::IsOrientationInherited() const
-{
- return mInheritOrientation;
-}
-
void Actor::SetSizeModeFactor( const Vector3& factor )
{
- EnsureRelayoutData();
+ EnsureRelayouter();
mRelayoutData->sizeModeFactor = factor;
}
return mRelayoutData->sizeModeFactor;
}
- return GetDefaultSizeModeFactor();
+ return Relayouter::DEFAULT_SIZE_MODE_FACTOR;
}
void Actor::SetColorMode( ColorMode colorMode )
SetColorModeMessage( GetEventThreadServices(), GetNode(), colorMode );
}
-ColorMode Actor::GetColorMode() const
-{
- // we have cached copy
- return mColorMode;
-}
-
void Actor::SetSize( float width, float height )
{
SetSize( Vector2( width, height ) );
void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
{
- EnsureRelayoutData();
-
- ResizePolicy::Type originalWidthPolicy = GetResizePolicy(Dimension::WIDTH);
- ResizePolicy::Type originalHeightPolicy = GetResizePolicy(Dimension::HEIGHT);
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- if ( policy == ResizePolicy::USE_ASSIGNED_SIZE )
- {
- mRelayoutData->useAssignedSize[ i ] = true;
- }
- else
- {
- mRelayoutData->resizePolicies[ i ] = policy;
- mRelayoutData->useAssignedSize[ i ] = false;
- }
- }
- }
-
- if( policy == ResizePolicy::DIMENSION_DEPENDENCY )
- {
- if( dimension & Dimension::WIDTH )
- {
- SetDimensionDependency( Dimension::WIDTH, Dimension::HEIGHT );
- }
-
- if( dimension & Dimension::HEIGHT )
- {
- SetDimensionDependency( Dimension::HEIGHT, Dimension::WIDTH );
- }
- }
-
- // If calling SetResizePolicy, assume we want relayout enabled
- SetRelayoutEnabled( true );
-
- // If the resize policy is set to be FIXED, the preferred size
- // should be overrided by the target size. Otherwise the target
- // size should be overrided by the preferred size.
-
- if( dimension & Dimension::WIDTH )
- {
- if( originalWidthPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
- {
- mRelayoutData->preferredSize.width = mTargetSize.width;
- }
- else if( originalWidthPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
- {
- mTargetSize.width = mRelayoutData->preferredSize.width;
- }
- }
-
- if( dimension & Dimension::HEIGHT )
- {
- if( originalHeightPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
- {
- mRelayoutData->preferredSize.height = mTargetSize.height;
- }
- else if( originalHeightPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
- {
- mTargetSize.height = mRelayoutData->preferredSize.height;
- }
- }
+ EnsureRelayouter().SetResizePolicy(policy, dimension, mTargetSize);
OnSetResizePolicy( policy, dimension );
{
if ( mRelayoutData )
{
- // If more than one dimension is requested, just return the first one found
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( ( dimension & ( 1 << i ) ) )
- {
- if( mRelayoutData->useAssignedSize[ i ] )
- {
- return ResizePolicy::USE_ASSIGNED_SIZE;
- }
- else
- {
- return mRelayoutData->resizePolicies[ i ];
- }
- }
- }
+ return mRelayoutData->GetResizePolicy(dimension);
}
return ResizePolicy::DEFAULT;
void Actor::SetSizeScalePolicy( SizeScalePolicy::Type policy )
{
- EnsureRelayoutData();
+ EnsureRelayouter();
mRelayoutData->sizeSetPolicy = policy;
return mRelayoutData->sizeSetPolicy;
}
- return DEFAULT_SIZE_SCALE_POLICY;
+ return Relayouter::DEFAULT_SIZE_SCALE_POLICY;
}
void Actor::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
{
- EnsureRelayoutData();
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->dimensionDependencies[ i ] = dependency;
- }
- }
+ EnsureRelayouter().SetDimensionDependency(dimension, dependency);
}
Dimension::Type Actor::GetDimensionDependency( Dimension::Type dimension ) const
{
if ( mRelayoutData )
{
- // If more than one dimension is requested, just return the first one found
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( ( dimension & ( 1 << i ) ) )
- {
- return mRelayoutData->dimensionDependencies[ i ];
- }
- }
+ return mRelayoutData->GetDimensionDependency(dimension);
}
return Dimension::ALL_DIMENSIONS; // Default
// to disable it, do nothing
if( mRelayoutData || relayoutEnabled )
{
- EnsureRelayoutData();
+ EnsureRelayouter();
DALI_ASSERT_DEBUG( mRelayoutData && "mRelayoutData not created" );
void Actor::SetLayoutDirty( bool dirty, Dimension::Type dimension )
{
- EnsureRelayoutData();
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->dimensionDirty[ i ] = dirty;
- }
- }
+ EnsureRelayouter().SetLayoutDirty(dirty, dimension);
}
bool Actor::IsLayoutDirty( Dimension::Type dimension ) const
{
- if ( mRelayoutData )
- {
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionDirty[ i ] )
- {
- return true;
- }
- }
- }
-
- return false;
+ return mRelayoutData && mRelayoutData->IsLayoutDirty(dimension);
}
bool Actor::RelayoutPossible( Dimension::Type dimension ) const
}
}
-bool Actor::IsOverlay() const
-{
- return ( DrawMode::OVERLAY_2D == mDrawMode );
-}
-
void Actor::SetDrawMode( DrawMode::Type drawMode )
{
// this flag is not animatable so keep the value
SetDrawModeMessage( GetEventThreadServices(), GetNode(), drawMode );
}
-DrawMode::Type Actor::GetDrawMode() const
-{
- return mDrawMode;
-}
-
bool Actor::ScreenToLocal( float& localX, float& localY, float screenX, float screenY ) const
{
// only valid when on-stage
bool Actor::ScreenToLocal( const Matrix& viewMatrix, const Matrix& projectionMatrix, const Viewport& viewport, float& localX, float& localY, float screenX, float screenY ) const
{
- // Early-out if not on stage
- if( !OnScene() )
+ return OnScene() && ScreenToLocalInternal(viewMatrix, projectionMatrix, GetNode().GetWorldMatrix(0), viewport, GetCurrentSize(), localX, localY, screenX, screenY);
+}
+
+ActorGestureData& Actor::GetGestureData()
+{
+ // Likely scenario is that once gesture-data is created for this actor, the actor will require
+ // that gesture for its entire life-time so no need to destroy it until the actor is destroyed
+ if( nullptr == mGestureData )
{
- return false;
+ mGestureData = new ActorGestureData;
}
+ return *mGestureData;
+}
- // Get the ModelView matrix
- Matrix modelView;
- Matrix::Multiply( modelView, GetNode().GetWorldMatrix(0), viewMatrix );
-
- // Calculate the inverted ModelViewProjection matrix; this will be used for 2 unprojects
- Matrix invertedMvp( false/*don't init*/);
- Matrix::Multiply( invertedMvp, modelView, projectionMatrix );
- bool success = invertedMvp.Invert();
-
- // Convert to GL coordinates
- Vector4 screenPos( screenX - static_cast<float>( viewport.x ), static_cast<float>( viewport.height ) - screenY - static_cast<float>( viewport.y ), 0.f, 1.f );
-
- Vector4 nearPos;
- if( success )
- {
- success = Unproject( screenPos, invertedMvp, static_cast<float>( viewport.width ), static_cast<float>( viewport.height ), nearPos );
- }
-
- Vector4 farPos;
- if( success )
- {
- screenPos.z = 1.0f;
- success = Unproject( screenPos, invertedMvp, static_cast<float>( viewport.width ), static_cast<float>( viewport.height ), farPos );
- }
-
- if( success )
- {
- Vector4 local;
- if( XyPlaneIntersect( nearPos, farPos, local ) )
- {
- Vector3 size = GetCurrentSize();
- localX = local.x + size.x * 0.5f;
- localY = local.y + size.y * 0.5f;
- }
- else
- {
- success = false;
- }
- }
-
- return success;
-}
-
-bool Actor::RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const
-{
- /*
- http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
-
- Mathematical Formulation
-
- Given the above mentioned sphere, a point 'p' lies on the surface of the sphere if
-
- ( p - c ) dot ( p - c ) = r^2
-
- Given a ray with a point of origin 'o', and a direction vector 'd':
-
- ray(t) = o + td, t >= 0
-
- we can find the t at which the ray intersects the sphere by setting ray(t) equal to 'p'
-
- (o + td - c ) dot ( o + td - c ) = r^2
-
- To solve for t we first expand the above into a more recognisable quadratic equation form
-
- ( d dot d )t^2 + 2( o - c ) dot dt + ( o - c ) dot ( o - c ) - r^2 = 0
-
- or
-
- At2 + Bt + C = 0
-
- where
-
- A = d dot d
- B = 2( o - c ) dot d
- C = ( o - c ) dot ( o - c ) - r^2
-
- which can be solved using a standard quadratic formula.
-
- Note that in the absence of positive, real, roots, the ray does not intersect the sphere.
-
- Practical Simplification
-
- In a renderer, we often differentiate between world space and object space. In the object space
- of a sphere it is centred at origin, meaning that if we first transform the ray from world space
- into object space, the mathematical solution presented above can be simplified significantly.
-
- If a sphere is centred at origin, a point 'p' lies on a sphere of radius r2 if
-
- p dot p = r^2
-
- and we can find the t at which the (transformed) ray intersects the sphere by
-
- ( o + td ) dot ( o + td ) = r^2
-
- According to the reasoning above, we expand the above quadratic equation into the general form
-
- At2 + Bt + C = 0
-
- which now has coefficients:
-
- A = d dot d
- B = 2( d dot o )
- C = o dot o - r^2
- */
-
- // Early-out if not on stage
- if( !OnScene() )
- {
- return false;
- }
-
- BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
-
- // Transforms the ray to the local reference system. As the test is against a sphere, only the translation and scale are needed.
- const Vector3& translation( GetNode().GetWorldPosition( bufferIndex ) );
- Vector3 rayOriginLocal( rayOrigin.x - translation.x, rayOrigin.y - translation.y, rayOrigin.z - translation.z );
-
- // Compute the radius is not needed, square radius it's enough.
- const Vector3& size( GetNode().GetSize( bufferIndex ) );
-
- // Scale the sphere.
- const Vector3& scale( GetNode().GetWorldScale( bufferIndex ) );
-
- const float width = size.width * scale.width;
- const float height = size.height * scale.height;
-
- float squareSphereRadius = 0.5f * ( width * width + height * height );
-
- float a = rayDir.Dot( rayDir ); // a
- float b2 = rayDir.Dot( rayOriginLocal ); // b/2
- float c = rayOriginLocal.Dot( rayOriginLocal ) - squareSphereRadius; // c
-
- return ( b2 * b2 - a * c ) >= 0.f;
-}
-
-bool Actor::RayActorTest( const Vector4& rayOrigin, const Vector4& rayDir, Vector2& hitPointLocal, float& distance ) const
-{
- bool hit = false;
-
- if( OnScene() )
- {
- // Transforms the ray to the local reference system.
- // Calculate the inverse of Model matrix
- Matrix invModelMatrix( false/*don't init*/);
-
- BufferIndex bufferIndex( GetEventThreadServices().GetEventBufferIndex() );
- invModelMatrix = GetNode().GetWorldMatrix(0);
- invModelMatrix.Invert();
-
- Vector4 rayOriginLocal( invModelMatrix * rayOrigin );
- Vector4 rayDirLocal( invModelMatrix * rayDir - invModelMatrix.GetTranslation() );
-
- // Test with the actor's XY plane (Normal = 0 0 1 1).
-
- float a = -rayOriginLocal.z;
- float b = rayDirLocal.z;
-
- if( fabsf( b ) > Math::MACHINE_EPSILON_1 )
- {
- // Ray travels distance * rayDirLocal to intersect with plane.
- distance = a / b;
-
- const Vector3& size = GetNode().GetSize( bufferIndex );
-
- hitPointLocal.x = rayOriginLocal.x + rayDirLocal.x * distance + size.x * 0.5f;
- hitPointLocal.y = rayOriginLocal.y + rayDirLocal.y * distance + size.y * 0.5f;
-
- // Test with the actor's geometry.
- hit = ( hitPointLocal.x >= 0.f ) && ( hitPointLocal.x <= size.x ) && ( hitPointLocal.y >= 0.f ) && ( hitPointLocal.y <= size.y );
- }
- }
-
- return hit;
-}
-
-void Actor::SetLeaveRequired( bool required )
-{
- mLeaveRequired = required;
-}
-
-bool Actor::GetLeaveRequired() const
-{
- return mLeaveRequired;
-}
-
-void Actor::SetKeyboardFocusable( bool focusable )
-{
- mKeyboardFocusable = focusable;
-}
-
-bool Actor::IsKeyboardFocusable() const
-{
- return mKeyboardFocusable;
-}
-
-bool Actor::GetTouchRequired() const
-{
- return !mTouchedSignal.Empty();
-}
-
-bool Actor::GetHoverRequired() const
-{
- return !mHoveredSignal.Empty();
-}
-
-bool Actor::GetWheelEventRequired() const
-{
- return !mWheelEventSignal.Empty();
-}
-
-bool Actor::IsHittable() const
-{
- return IsSensitive() && IsVisible() && ( GetCurrentWorldColor().a > FULLY_TRANSPARENT ) && IsNodeConnected();
-}
-
-ActorGestureData& Actor::GetGestureData()
-{
- // Likely scenario is that once gesture-data is created for this actor, the actor will require
- // that gesture for its entire life-time so no need to destroy it until the actor is destroyed
- if( NULL == mGestureData )
- {
- mGestureData = new ActorGestureData;
- }
- return *mGestureData;
-}
-
-bool Actor::IsGestureRequired( GestureType::Value type ) const
-{
- return mGestureData && mGestureData->IsGestureRequired( type );
-}
+bool Actor::IsGestureRequired( GestureType::Value type ) const
+{
+ return mGestureData && mGestureData->IsGestureRequired( type );
+}
bool Actor::EmitTouchEventSignal( const Dali::TouchEvent& touch )
{
- bool consumed = false;
-
- if( !mTouchedSignal.Empty() )
- {
- Dali::Actor handle( this );
- consumed = mTouchedSignal.Emit( handle, touch );
- }
-
- return consumed;
+ return EmitConsumingSignal( *this, mTouchedSignal, touch );
}
bool Actor::EmitHoverEventSignal( const Dali::HoverEvent& event )
{
- bool consumed = false;
-
- if( !mHoveredSignal.Empty() )
- {
- Dali::Actor handle( this );
- consumed = mHoveredSignal.Emit( handle, event );
- }
-
- return consumed;
+ return EmitConsumingSignal( *this, mHoveredSignal, event );
}
bool Actor::EmitWheelEventSignal( const Dali::WheelEvent& event )
{
- bool consumed = false;
-
- if( !mWheelEventSignal.Empty() )
- {
- Dali::Actor handle( this );
- consumed = mWheelEventSignal.Emit( handle, event );
- }
-
- return consumed;
+ return EmitConsumingSignal( *this, mWheelEventSignal, event );
}
void Actor::EmitVisibilityChangedSignal( bool visible, DevelActor::VisibilityChange::Type type )
{
- if( ! mVisibilityChangedSignal.Empty() )
- {
- Dali::Actor handle( this );
- mVisibilityChangedSignal.Emit( handle, visible, type );
- }
+ EmitSignal( *this, mVisibilityChangedSignal, visible, type );
}
void Actor::EmitLayoutDirectionChangedSignal( LayoutDirection::Type type )
{
- if( ! mLayoutDirectionChangedSignal.Empty() )
- {
- Dali::Actor handle( this );
- mLayoutDirectionChangedSignal.Emit( handle, type );
- }
+ EmitSignal( *this, mLayoutDirectionChangedSignal, type );
}
void Actor::EmitChildAddedSignal( Actor& child )
{
- if( ! mChildAddedSignal.Empty() )
- {
- Dali::Actor handle( &child );
- mChildAddedSignal.Emit( handle );
- }
+ EmitSignal( child, mChildAddedSignal );
}
void Actor::EmitChildRemovedSignal( Actor& child )
{
- if( ! mChildRemovedSignal.Empty() )
- {
- Dali::Actor handle( &child );
- mChildRemovedSignal.Emit( handle );
- }
-}
-
-Dali::Actor::TouchEventSignalType& Actor::TouchedSignal()
-{
- return mTouchedSignal;
-}
-
-Dali::Actor::HoverSignalType& Actor::HoveredSignal()
-{
- return mHoveredSignal;
-}
-
-Dali::Actor::WheelEventSignalType& Actor::WheelEventSignal()
-{
- return mWheelEventSignal;
-}
-
-Dali::Actor::OnSceneSignalType& Actor::OnSceneSignal()
-{
- return mOnSceneSignal;
-}
-
-Dali::Actor::OffSceneSignalType& Actor::OffSceneSignal()
-{
- return mOffSceneSignal;
-}
-
-Dali::Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
-{
- return mOnRelayoutSignal;
-}
-
-DevelActor::VisibilityChangedSignalType& Actor::VisibilityChangedSignal()
-{
- return mVisibilityChangedSignal;
-}
-
-Dali::Actor::LayoutDirectionChangedSignalType& Actor::LayoutDirectionChangedSignal()
-{
- return mLayoutDirectionChangedSignal;
-}
-
-DevelActor::ChildChangedSignalType& Actor::ChildAddedSignal()
-{
- return mChildAddedSignal;
-}
-
-DevelActor::ChildChangedSignalType& Actor::ChildRemovedSignal()
-{
- return mChildRemovedSignal;
-}
-
-DevelActor::ChildOrderChangedSignalType& Actor::ChildOrderChangedSignal()
-{
- return mChildOrderChangedSignal;
+ EmitSignal( child, mChildRemovedSignal );
}
bool Actor::DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor )
Actor::Actor( DerivedType derivedType, const SceneGraph::Node& node )
: Object( &node ),
mScene( nullptr ),
- mParent( NULL ),
- mChildren( NULL ),
- mRenderers( NULL ),
- mParentOrigin( NULL ),
- mAnchorPoint( NULL ),
- mRelayoutData( NULL ),
- mGestureData( NULL ),
+ mParent( nullptr ),
+ mChildren( nullptr ),
+ mRenderers( nullptr ),
+ mParentOrigin( nullptr ),
+ mAnchorPoint( nullptr ),
+ mRelayoutData( nullptr ),
+ mGestureData( nullptr ),
mTouchedSignal(),
mHoveredSignal(),
mWheelEventSignal(),
ActorConstIter endIter = mChildren->end();
for( ActorIter iter = mChildren->begin(); iter != endIter; ++iter )
{
- (*iter)->SetParent( NULL );
+ (*iter)->SetParent( nullptr );
}
}
delete mChildren;
void Actor::SetDefaultProperty( Property::Index index, const Property::Value& property )
{
- switch( index )
- {
- case Dali::Actor::Property::PARENT_ORIGIN:
- {
- Property::Type type = property.GetType();
- if( type == Property::VECTOR3 )
- {
- SetParentOrigin( property.Get< Vector3 >() );
- }
- else if ( type == Property::STRING )
- {
- std::string parentOriginString;
- property.Get( parentOriginString );
- Vector3 parentOrigin;
- if( GetParentOriginConstant( parentOriginString, parentOrigin ) )
- {
- SetParentOrigin( parentOrigin );
- }
- }
- break;
- }
+ PropertyHandler::SetDefaultProperty(*this, index, property);
+}
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- {
- SetParentOriginX( property.Get< float >() );
- break;
- }
+// TODO: This method needs to be removed
+void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
+{
+ PropertyHandler::SetSceneGraphProperty(index, entry, value, GetEventThreadServices(), GetNode());
+}
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- {
- SetParentOriginY( property.Get< float >() );
- break;
- }
+Property::Value Actor::GetDefaultProperty( Property::Index index ) const
+{
+ Property::Value value;
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- {
- SetParentOriginZ( property.Get< float >() );
- break;
- }
+ if( ! GetCachedPropertyValue( index, value ) )
+ {
+ // If property value is not stored in the event-side, then it must be a scene-graph only property
+ GetCurrentPropertyValue( index, value );
+ }
- case Dali::Actor::Property::ANCHOR_POINT:
- {
- Property::Type type = property.GetType();
- if( type == Property::VECTOR3 )
- {
- SetAnchorPoint( property.Get< Vector3 >() );
- }
- else if ( type == Property::STRING )
- {
- std::string anchorPointString;
- property.Get( anchorPointString );
- Vector3 anchor;
- if( GetAnchorPointConstant( anchorPointString, anchor ) )
- {
- SetAnchorPoint( anchor );
- }
- }
- break;
- }
+ return value;
+}
- case Dali::Actor::Property::ANCHOR_POINT_X:
- {
- SetAnchorPointX( property.Get< float >() );
- break;
- }
+Property::Value Actor::GetDefaultPropertyCurrentValue( Property::Index index ) const
+{
+ Property::Value value;
- case Dali::Actor::Property::ANCHOR_POINT_Y:
- {
- SetAnchorPointY( property.Get< float >() );
- break;
- }
+ if( ! GetCurrentPropertyValue( index, value ) )
+ {
+ // If unable to retrieve scene-graph property value, then it must be an event-side only property
+ GetCachedPropertyValue( index, value );
+ }
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- {
- SetAnchorPointZ( property.Get< float >() );
- break;
- }
+ return value;
+}
- case Dali::Actor::Property::SIZE:
- {
- Property::Type type = property.GetType();
- if( type == Property::VECTOR2 )
- {
- SetSize( property.Get< Vector2 >() );
- }
- else if ( type == Property::VECTOR3 )
- {
- SetSize( property.Get< Vector3 >() );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- SetWidth( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- SetHeight( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- SetDepth( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::POSITION:
- {
- Property::Type type = property.GetType();
- if( type == Property::VECTOR2 )
- {
- Vector2 position = property.Get< Vector2 >();
- SetPosition( Vector3( position.x, position.y, 0.0f ) );
- }
- else if ( type == Property::VECTOR3 )
- {
- SetPosition( property.Get< Vector3 >() );
- }
- break;
- }
-
- case Dali::Actor::Property::POSITION_X:
- {
- SetX( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::POSITION_Y:
- {
- SetY( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::POSITION_Z:
- {
- SetZ( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::ORIENTATION:
- {
- SetOrientation( property.Get< Quaternion >() );
- break;
- }
-
- case Dali::Actor::Property::SCALE:
- {
- Property::Type type = property.GetType();
- if( type == Property::FLOAT )
- {
- float scale = property.Get< float >();
- SetScale( scale, scale, scale );
- }
- else if ( type == Property::VECTOR3 )
- {
- SetScale( property.Get< Vector3 >() );
- }
- break;
- }
-
- case Dali::Actor::Property::SCALE_X:
- {
- SetScaleX( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::SCALE_Y:
- {
- SetScaleY( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::SCALE_Z:
- {
- SetScaleZ( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::VISIBLE:
- {
- SetVisible( property.Get< bool >() );
- break;
- }
-
- case Dali::Actor::Property::COLOR:
- {
- Property::Type type = property.GetType();
- if( type == Property::VECTOR3 )
- {
- Vector3 color = property.Get< Vector3 >();
- SetColor( Vector4( color.r, color.g, color.b, 1.0f ) );
- }
- else if( type == Property::VECTOR4 )
- {
- SetColor( property.Get< Vector4 >() );
- }
- break;
- }
-
- case Dali::Actor::Property::COLOR_RED:
- {
- SetColorRed( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::COLOR_GREEN:
- {
- SetColorGreen( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::COLOR_BLUE:
- {
- SetColorBlue( property.Get< float >() );
- break;
- }
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::Actor::Property::OPACITY:
- {
- float value;
- if( property.Get( value ) )
- {
- SetOpacity( value );
- }
- break;
- }
-
- case Dali::Actor::Property::NAME:
- {
- SetName( property.Get< std::string >() );
- break;
- }
-
- case Dali::Actor::Property::SENSITIVE:
- {
- SetSensitive( property.Get< bool >() );
- break;
- }
-
- case Dali::Actor::Property::LEAVE_REQUIRED:
- {
- SetLeaveRequired( property.Get< bool >() );
- break;
- }
-
- case Dali::Actor::Property::INHERIT_POSITION:
- {
- SetInheritPosition( property.Get< bool >() );
- break;
- }
-
- case Dali::Actor::Property::INHERIT_ORIENTATION:
- {
- SetInheritOrientation( property.Get< bool >() );
- break;
- }
-
- case Dali::Actor::Property::INHERIT_SCALE:
- {
- SetInheritScale( property.Get< bool >() );
- break;
- }
-
- case Dali::Actor::Property::COLOR_MODE:
- {
- ColorMode mode = mColorMode;
- if ( Scripting::GetEnumerationProperty< ColorMode >( property, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode ) )
- {
- SetColorMode( mode );
- }
- break;
- }
-
- case Dali::Actor::Property::DRAW_MODE:
- {
- DrawMode::Type mode = mDrawMode;
- if( Scripting::GetEnumerationProperty< DrawMode::Type >( property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
- {
- SetDrawMode( mode );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_MODE_FACTOR:
- {
- SetSizeModeFactor( property.Get< Vector3 >() );
- break;
- }
-
- case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
- {
- ResizePolicy::Type type = GetResizePolicy( Dimension::WIDTH );
- if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
- {
- SetResizePolicy( type, Dimension::WIDTH );
- }
- break;
- }
-
- case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
- {
- ResizePolicy::Type type = GetResizePolicy( Dimension::HEIGHT );
- if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
- {
- SetResizePolicy( type, Dimension::HEIGHT );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_SCALE_POLICY:
- {
- SizeScalePolicy::Type type = GetSizeScalePolicy();
- if( Scripting::GetEnumerationProperty< SizeScalePolicy::Type >( property, SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
- {
- SetSizeScalePolicy( type );
- }
- break;
- }
-
- case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
- {
- if( property.Get< bool >() )
- {
- SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
- }
- break;
- }
-
- case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
- {
- if( property.Get< bool >() )
- {
- SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
- }
- break;
- }
-
- case Dali::Actor::Property::PADDING:
- {
- Vector4 padding = property.Get< Vector4 >();
- SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
- SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
- break;
- }
-
- case Dali::Actor::Property::MINIMUM_SIZE:
- {
- Vector2 size = property.Get< Vector2 >();
- SetMinimumSize( size.x, Dimension::WIDTH );
- SetMinimumSize( size.y, Dimension::HEIGHT );
- break;
- }
-
- case Dali::Actor::Property::MAXIMUM_SIZE:
- {
- Vector2 size = property.Get< Vector2 >();
- SetMaximumSize( size.x, Dimension::WIDTH );
- SetMaximumSize( size.y, Dimension::HEIGHT );
- break;
- }
-
- case Dali::DevelActor::Property::SIBLING_ORDER:
- {
- int value;
-
- if( property.Get( value ) )
- {
- SetSiblingOrder( value );
- }
- break;
- }
-
- case Dali::Actor::Property::CLIPPING_MODE:
- {
- ClippingMode::Type convertedValue = mClippingMode;
- if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
- {
- mClippingMode = convertedValue;
- SetClippingModeMessage( GetEventThreadServices(), GetNode(), mClippingMode );
- }
- break;
- }
-
- case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
- {
- bool value = false;
- if( property.Get( value ) && value != mPositionUsesAnchorPoint )
- {
- mPositionUsesAnchorPoint = value;
- SetPositionUsesAnchorPointMessage( GetEventThreadServices(), GetNode(), mPositionUsesAnchorPoint );
- }
- break;
- }
-
- case Dali::Actor::Property::LAYOUT_DIRECTION:
- {
- Dali::LayoutDirection::Type direction = mLayoutDirection;
- mInheritLayoutDirection = false;
-
- if( Scripting::GetEnumerationProperty< LayoutDirection::Type >( property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction ) )
- {
- InheritLayoutDirectionRecursively( this, direction, true );
- }
- break;
- }
-
- case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
- {
- bool value = false;
- if( property.Get( value ) )
- {
- SetInheritLayoutDirection( value );
- }
- break;
- }
-
- case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
- {
- bool value = false;
- if( property.Get( value ) )
- {
- SetKeyboardFocusable( value );
- }
- break;
- }
-
- case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
- {
- SetUpdateSizeHint( property.Get< Vector2 >() );
- break;
- }
-
- case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
- {
- bool boolValue = false;
- if ( property.Get( boolValue ) )
- {
- mCaptureAllTouchAfterStart = boolValue;
- }
- break;
- }
-
- default:
- {
- // this can happen in the case of a non-animatable default property so just do nothing
- break;
- }
- }
-}
-
-// TODO: This method needs to be removed
-void Actor::SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value )
-{
- switch( entry.GetType() )
- {
- case Property::BOOLEAN:
- {
- const AnimatableProperty< bool >* property = dynamic_cast< const AnimatableProperty< bool >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<bool>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
-
- break;
- }
-
- case Property::INTEGER:
- {
- const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<int>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<int>::Bake, value.Get<int>() );
-
- break;
- }
-
- case Property::FLOAT:
- {
- const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<float>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<float>::Bake, value.Get<float>() );
-
- break;
- }
-
- case Property::VECTOR2:
- {
- const AnimatableProperty< Vector2 >* property = dynamic_cast< const AnimatableProperty< Vector2 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- if(entry.componentIndex == 0)
- {
- SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
- }
- else if(entry.componentIndex == 1)
- {
- SceneGraph::NodePropertyComponentMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
- }
- else
- {
- SceneGraph::NodePropertyMessage<Vector2>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
- }
-
- break;
- }
-
- case Property::VECTOR3:
- {
- const AnimatableProperty< Vector3 >* property = dynamic_cast< const AnimatableProperty< Vector3 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- if(entry.componentIndex == 0)
- {
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
- }
- else if(entry.componentIndex == 1)
- {
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
- }
- else if(entry.componentIndex == 2)
- {
- SceneGraph::NodePropertyComponentMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
- }
- else
- {
- SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
- }
-
- break;
- }
-
- case Property::VECTOR4:
- {
- const AnimatableProperty< Vector4 >* property = dynamic_cast< const AnimatableProperty< Vector4 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- if(entry.componentIndex == 0)
- {
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
- }
- else if(entry.componentIndex == 1)
- {
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
- }
- else if(entry.componentIndex == 2)
- {
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
- }
- else if(entry.componentIndex == 3)
- {
- SceneGraph::NodePropertyComponentMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
- }
- else
- {
- SceneGraph::NodePropertyMessage<Vector4>::Send( GetEventThreadServices(), &GetNode(), property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
- }
-
- break;
- }
-
- case Property::ROTATION:
- {
- const AnimatableProperty< Quaternion >* property = dynamic_cast< const AnimatableProperty< Quaternion >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Quaternion>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
-
- break;
- }
-
- case Property::MATRIX:
- {
- const AnimatableProperty< Matrix >* property = dynamic_cast< const AnimatableProperty< Matrix >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
-
- break;
- }
-
- case Property::MATRIX3:
- {
- const AnimatableProperty< Matrix3 >* property = dynamic_cast< const AnimatableProperty< Matrix3 >* >( entry.GetSceneGraphProperty() );
- DALI_ASSERT_DEBUG( NULL != property );
-
- // property is being used in a separate thread; queue a message to set the property
- SceneGraph::NodePropertyMessage<Matrix3>::Send( GetEventThreadServices(), &GetNode(), property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
-
- break;
- }
-
- default:
- {
- // nothing to do for other types
- }
- } // entry.GetType
-}
-
-Property::Value Actor::GetDefaultProperty( Property::Index index ) const
-{
- Property::Value value;
-
- if( ! GetCachedPropertyValue( index, value ) )
- {
- // If property value is not stored in the event-side, then it must be a scene-graph only property
- GetCurrentPropertyValue( index, value );
- }
-
- return value;
-}
-
-Property::Value Actor::GetDefaultPropertyCurrentValue( Property::Index index ) const
-{
- Property::Value value;
-
- if( ! GetCurrentPropertyValue( index, value ) )
- {
- // If unable to retrieve scene-graph property value, then it must be an event-side only property
- GetCachedPropertyValue( index, value );
- }
-
- return value;
-}
-
-void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType )
-{
- switch( animationType )
- {
- case Animation::TO:
- case Animation::BETWEEN:
- {
- switch( index )
- {
- case Dali::Actor::Property::SIZE:
- {
- if( value.Get( mTargetSize ) )
- {
- mAnimatedSize = mTargetSize;
- mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- if( value.Get( mTargetSize.width ) )
- {
- mAnimatedSize.width = mTargetSize.width;
- mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- if( value.Get( mTargetSize.height ) )
- {
- mAnimatedSize.height = mTargetSize.height;
- mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- if( value.Get( mTargetSize.depth ) )
- {
- mAnimatedSize.depth = mTargetSize.depth;
- mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::POSITION:
- {
- value.Get( mTargetPosition );
- break;
- }
-
- case Dali::Actor::Property::POSITION_X:
- {
- value.Get( mTargetPosition.x );
- break;
- }
-
- case Dali::Actor::Property::POSITION_Y:
- {
- value.Get( mTargetPosition.y );
- break;
- }
-
- case Dali::Actor::Property::POSITION_Z:
- {
- value.Get( mTargetPosition.z );
- break;
- }
-
- case Dali::Actor::Property::ORIENTATION:
- {
- value.Get( mTargetOrientation );
- break;
- }
-
- case Dali::Actor::Property::SCALE:
- {
- value.Get( mTargetScale );
- break;
- }
-
- case Dali::Actor::Property::SCALE_X:
- {
- value.Get( mTargetScale.x );
- break;
- }
-
- case Dali::Actor::Property::SCALE_Y:
- {
- value.Get( mTargetScale.y );
- break;
- }
-
- case Dali::Actor::Property::SCALE_Z:
- {
- value.Get( mTargetScale.z );
- break;
- }
-
- case Dali::Actor::Property::VISIBLE:
- {
- SetVisibleInternal( value.Get< bool >(), SendMessage::FALSE );
- break;
- }
-
- case Dali::Actor::Property::COLOR:
- {
- value.Get( mTargetColor );
- break;
- }
-
- case Dali::Actor::Property::COLOR_RED:
- {
- value.Get( mTargetColor.r );
- break;
- }
-
- case Dali::Actor::Property::COLOR_GREEN:
- {
- value.Get( mTargetColor.g );
- break;
- }
-
- case Dali::Actor::Property::COLOR_BLUE:
- {
- value.Get( mTargetColor.b );
- break;
- }
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::Actor::Property::OPACITY:
- {
- value.Get( mTargetColor.a );
- break;
- }
-
- default:
- {
- // Not an animatable property. Do nothing.
- break;
- }
- }
- break;
- }
-
- case Animation::BY:
- {
- switch( index )
- {
- case Dali::Actor::Property::SIZE:
- {
- if( AdjustValue< Vector3 >( mTargetSize, value ) )
- {
- mAnimatedSize = mTargetSize;
- mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- if( AdjustValue< float >( mTargetSize.width, value ) )
- {
- mAnimatedSize.width = mTargetSize.width;
- mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- if( AdjustValue< float >( mTargetSize.height, value ) )
- {
- mAnimatedSize.height = mTargetSize.height;
- mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- if( AdjustValue< float >( mTargetSize.depth, value ) )
- {
- mAnimatedSize.depth = mTargetSize.depth;
- mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
-
- // Notify deriving classes
- OnSizeAnimation( animation, mTargetSize );
- }
- break;
- }
-
- case Dali::Actor::Property::POSITION:
- {
- AdjustValue< Vector3 >( mTargetPosition, value );
- break;
- }
-
- case Dali::Actor::Property::POSITION_X:
- {
- AdjustValue< float >( mTargetPosition.x, value );
- break;
- }
-
- case Dali::Actor::Property::POSITION_Y:
- {
- AdjustValue< float >( mTargetPosition.y, value );
- break;
- }
-
- case Dali::Actor::Property::POSITION_Z:
- {
- AdjustValue< float >( mTargetPosition.z, value );
- break;
- }
-
- case Dali::Actor::Property::ORIENTATION:
- {
- Quaternion relativeValue;
- if( value.Get( relativeValue ) )
- {
- mTargetOrientation *= relativeValue;
- }
- break;
- }
-
- case Dali::Actor::Property::SCALE:
- {
- AdjustValue< Vector3 >( mTargetScale, value );
- break;
- }
-
- case Dali::Actor::Property::SCALE_X:
- {
- AdjustValue< float >( mTargetScale.x, value );
- break;
- }
-
- case Dali::Actor::Property::SCALE_Y:
- {
- AdjustValue< float >( mTargetScale.y, value );
- break;
- }
-
- case Dali::Actor::Property::SCALE_Z:
- {
- AdjustValue< float >( mTargetScale.z, value );
- break;
- }
-
- case Dali::Actor::Property::VISIBLE:
- {
- bool relativeValue = false;
- if( value.Get( relativeValue ) )
- {
- bool visible = mVisible || relativeValue;
- SetVisibleInternal( visible, SendMessage::FALSE );
- }
- break;
- }
-
- case Dali::Actor::Property::COLOR:
- {
- AdjustValue< Vector4 >( mTargetColor, value );
- break;
- }
-
- case Dali::Actor::Property::COLOR_RED:
- {
- AdjustValue< float >( mTargetColor.r, value );
- break;
- }
-
- case Dali::Actor::Property::COLOR_GREEN:
- {
- AdjustValue< float >( mTargetColor.g, value );
- break;
- }
-
- case Dali::Actor::Property::COLOR_BLUE:
- {
- AdjustValue< float >( mTargetColor.b, value );
- break;
- }
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::Actor::Property::OPACITY:
- {
- AdjustValue< float >( mTargetColor.a, value );
- break;
- }
-
- default:
- {
- // Not an animatable property. Do nothing.
- break;
- }
- }
- break;
- }
- }
-}
-
-const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
-{
- const PropertyBase* property( NULL );
-
- switch( index )
- {
- case Dali::Actor::Property::SIZE: // FALLTHROUGH
- case Dali::Actor::Property::SIZE_WIDTH: // FALLTHROUGH
- case Dali::Actor::Property::SIZE_HEIGHT: // FALLTHROUGH
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- property = &GetNode().mSize;
- break;
- }
- case Dali::Actor::Property::POSITION: // FALLTHROUGH
- case Dali::Actor::Property::POSITION_X: // FALLTHROUGH
- case Dali::Actor::Property::POSITION_Y: // FALLTHROUGH
- case Dali::Actor::Property::POSITION_Z:
- {
- property = &GetNode().mPosition;
- break;
- }
- case Dali::Actor::Property::ORIENTATION:
- {
- property = &GetNode().mOrientation;
- break;
- }
- case Dali::Actor::Property::SCALE: // FALLTHROUGH
- case Dali::Actor::Property::SCALE_X: // FALLTHROUGH
- case Dali::Actor::Property::SCALE_Y: // FALLTHROUGH
- case Dali::Actor::Property::SCALE_Z:
- {
- property = &GetNode().mScale;
- break;
- }
- case Dali::Actor::Property::VISIBLE:
- {
- property = &GetNode().mVisible;
- break;
- }
- case Dali::Actor::Property::COLOR: // FALLTHROUGH
- case Dali::Actor::Property::COLOR_RED: // FALLTHROUGH
- case Dali::Actor::Property::COLOR_GREEN: // FALLTHROUGH
- case Dali::Actor::Property::COLOR_BLUE: // FALLTHROUGH
- case Dali::Actor::Property::COLOR_ALPHA: // FALLTHROUGH
- case Dali::Actor::Property::OPACITY:
- {
- property = &GetNode().mColor;
- break;
- }
- default:
- {
- break;
- }
- }
- if( !property )
- {
- // not our property, ask base
- property = Object::GetSceneObjectAnimatableProperty( index );
- }
-
- return property;
-}
-
-const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index index ) const
-{
- const PropertyInputImpl* property( NULL );
-
- switch( index )
- {
- case Dali::Actor::Property::PARENT_ORIGIN: // FALLTHROUGH
- case Dali::Actor::Property::PARENT_ORIGIN_X: // FALLTHROUGH
- case Dali::Actor::Property::PARENT_ORIGIN_Y: // FALLTHROUGH
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- {
- property = &GetNode().mParentOrigin;
- break;
- }
- case Dali::Actor::Property::ANCHOR_POINT: // FALLTHROUGH
- case Dali::Actor::Property::ANCHOR_POINT_X: // FALLTHROUGH
- case Dali::Actor::Property::ANCHOR_POINT_Y: // FALLTHROUGH
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- {
- property = &GetNode().mAnchorPoint;
- break;
- }
- case Dali::Actor::Property::WORLD_POSITION: // FALLTHROUGH
- case Dali::Actor::Property::WORLD_POSITION_X: // FALLTHROUGH
- case Dali::Actor::Property::WORLD_POSITION_Y: // FALLTHROUGH
- case Dali::Actor::Property::WORLD_POSITION_Z:
- {
- property = &GetNode().mWorldPosition;
- break;
- }
- case Dali::Actor::Property::WORLD_ORIENTATION:
- {
- property = &GetNode().mWorldOrientation;
- break;
- }
- case Dali::Actor::Property::WORLD_SCALE:
- {
- property = &GetNode().mWorldScale;
- break;
- }
- case Dali::Actor::Property::WORLD_COLOR:
- {
- property = &GetNode().mWorldColor;
- break;
- }
- case Dali::Actor::Property::WORLD_MATRIX:
- {
- property = &GetNode().mWorldMatrix;
- break;
- }
- case Dali::Actor::Property::CULLED:
- {
- property = &GetNode().mCulled;
- break;
- }
- default:
- {
- break;
- }
- }
- if( !property )
- {
- // reuse animatable property getter as animatable properties are inputs as well
- // animatable property chains back to Object::GetSceneObjectInputProperty() so all properties get covered
- property = GetSceneObjectAnimatableProperty( index );
- }
-
- return property;
-}
-
-int32_t Actor::GetPropertyComponentIndex( Property::Index index ) const
-{
- int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;
-
- switch( index )
- {
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- case Dali::Actor::Property::ANCHOR_POINT_X:
- case Dali::Actor::Property::SIZE_WIDTH:
- case Dali::Actor::Property::POSITION_X:
- case Dali::Actor::Property::WORLD_POSITION_X:
- case Dali::Actor::Property::SCALE_X:
- case Dali::Actor::Property::COLOR_RED:
- {
- componentIndex = 0;
- break;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- case Dali::Actor::Property::ANCHOR_POINT_Y:
- case Dali::Actor::Property::SIZE_HEIGHT:
- case Dali::Actor::Property::POSITION_Y:
- case Dali::Actor::Property::WORLD_POSITION_Y:
- case Dali::Actor::Property::SCALE_Y:
- case Dali::Actor::Property::COLOR_GREEN:
- {
- componentIndex = 1;
- break;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- case Dali::Actor::Property::SIZE_DEPTH:
- case Dali::Actor::Property::POSITION_Z:
- case Dali::Actor::Property::WORLD_POSITION_Z:
- case Dali::Actor::Property::SCALE_Z:
- case Dali::Actor::Property::COLOR_BLUE:
- {
- componentIndex = 2;
- break;
- }
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::Actor::Property::OPACITY:
- {
- componentIndex = 3;
- break;
- }
-
- default:
- {
- // Do nothing
- break;
- }
- }
- if( Property::INVALID_COMPONENT_INDEX == componentIndex )
- {
- // ask base
- componentIndex = Object::GetPropertyComponentIndex( index );
- }
-
- return componentIndex;
-}
-
-void Actor::SetParent( Actor* parent )
-{
- if( parent )
- {
- DALI_ASSERT_ALWAYS( !mParent && "Actor cannot have 2 parents" );
-
- mParent = parent;
-
- mScene = parent->mScene;
-
- if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- parent->OnScene() )
- {
- // Instruct each actor to create a corresponding node in the scene graph
- ConnectToScene( parent->GetHierarchyDepth() );
- }
-
- // Resolve the name and index for the child properties if any
- ResolveChildProperties();
- }
- else // parent being set to NULL
- {
- DALI_ASSERT_ALWAYS( mParent != NULL && "Actor should have a parent" );
-
- mParent = NULL;
-
- if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
- OnScene() )
- {
- // Disconnect the Node & its children from the scene-graph.
- DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );
-
- // Instruct each actor to discard pointers to the scene-graph
- DisconnectFromStage();
- }
-
- mScene = nullptr;
- }
-}
-
-bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
-{
- bool done = false;
- Actor* actor = dynamic_cast< Actor* >( object );
-
- if( actor )
- {
- if( 0 == actionName.compare( ACTION_SHOW ) )
- {
- actor->SetVisible( true );
- done = true;
- }
- else if( 0 == actionName.compare( ACTION_HIDE ) )
- {
- actor->SetVisible( false );
- done = true;
- }
- }
-
- return done;
-}
-
-Rect<> Actor::CalculateScreenExtents( ) const
-{
- auto screenPosition = GetCurrentScreenPosition();
- Vector3 size = GetCurrentSize() * GetCurrentWorldScale();
- Vector3 anchorPointOffSet = size * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
- Vector2 position = Vector2( screenPosition.x - anchorPointOffSet.x, screenPosition.y - anchorPointOffSet.y );
- return { position.x, position.y, size.x, size.y };
-}
-
-bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
-{
- bool valueSet = true;
-
- switch( index )
- {
- case Dali::Actor::Property::PARENT_ORIGIN:
- {
- value = GetCurrentParentOrigin();
- break;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_X:
- {
- value = GetCurrentParentOrigin().x;
- break;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_Y:
- {
- value = GetCurrentParentOrigin().y;
- break;
- }
-
- case Dali::Actor::Property::PARENT_ORIGIN_Z:
- {
- value = GetCurrentParentOrigin().z;
- break;
- }
-
- case Dali::Actor::Property::ANCHOR_POINT:
- {
- value = GetCurrentAnchorPoint();
- break;
- }
-
- case Dali::Actor::Property::ANCHOR_POINT_X:
- {
- value = GetCurrentAnchorPoint().x;
- break;
- }
-
- case Dali::Actor::Property::ANCHOR_POINT_Y:
- {
- value = GetCurrentAnchorPoint().y;
- break;
- }
-
- case Dali::Actor::Property::ANCHOR_POINT_Z:
- {
- value = GetCurrentAnchorPoint().z;
- break;
- }
-
- case Dali::Actor::Property::SIZE:
- {
- value = GetTargetSize();
- break;
- }
-
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- value = GetTargetSize().width;
- break;
- }
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- value = GetTargetSize().height;
- break;
- }
-
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- value = GetTargetSize().depth;
- break;
- }
-
- case Dali::Actor::Property::POSITION:
- {
- value = GetTargetPosition();
- break;
- }
-
- case Dali::Actor::Property::POSITION_X:
- {
- value = GetTargetPosition().x;
- break;
- }
-
- case Dali::Actor::Property::POSITION_Y:
- {
- value = GetTargetPosition().y;
- break;
- }
-
- case Dali::Actor::Property::POSITION_Z:
- {
- value = GetTargetPosition().z;
- break;
- }
-
- case Dali::Actor::Property::ORIENTATION:
- {
- value = mTargetOrientation;
- break;
- }
-
- case Dali::Actor::Property::SCALE:
- {
- value = mTargetScale;
- break;
- }
-
- case Dali::Actor::Property::SCALE_X:
- {
- value = mTargetScale.x;
- break;
- }
-
- case Dali::Actor::Property::SCALE_Y:
- {
- value = mTargetScale.y;
- break;
- }
-
- case Dali::Actor::Property::SCALE_Z:
- {
- value = mTargetScale.z;
- break;
- }
-
- case Dali::Actor::Property::VISIBLE:
- {
- value = mVisible;
- break;
- }
-
- case Dali::Actor::Property::COLOR:
- {
- value = mTargetColor;
- break;
- }
-
- case Dali::Actor::Property::COLOR_RED:
- {
- value = mTargetColor.r;
- break;
- }
-
- case Dali::Actor::Property::COLOR_GREEN:
- {
- value = mTargetColor.g;
- break;
- }
-
- case Dali::Actor::Property::COLOR_BLUE:
- {
- value = mTargetColor.b;
- break;
- }
-
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::Actor::Property::OPACITY:
- {
- value = mTargetColor.a;
- break;
- }
-
- case Dali::Actor::Property::NAME:
- {
- value = GetName();
- break;
- }
-
- case Dali::Actor::Property::SENSITIVE:
- {
- value = IsSensitive();
- break;
- }
-
- case Dali::Actor::Property::LEAVE_REQUIRED:
- {
- value = GetLeaveRequired();
- break;
- }
-
- case Dali::Actor::Property::INHERIT_POSITION:
- {
- value = IsPositionInherited();
- break;
- }
-
- case Dali::Actor::Property::INHERIT_ORIENTATION:
- {
- value = IsOrientationInherited();
- break;
- }
-
- case Dali::Actor::Property::INHERIT_SCALE:
- {
- value = IsScaleInherited();
- break;
- }
-
- case Dali::Actor::Property::COLOR_MODE:
- {
- value = GetColorMode();
- break;
- }
-
- case Dali::Actor::Property::DRAW_MODE:
- {
- value = GetDrawMode();
- break;
- }
-
- case Dali::Actor::Property::SIZE_MODE_FACTOR:
- {
- value = GetSizeModeFactor();
- break;
- }
-
- case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
- {
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
- break;
- }
-
- case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
- {
- value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
- break;
- }
-
- case Dali::Actor::Property::SIZE_SCALE_POLICY:
- {
- value = GetSizeScalePolicy();
- break;
- }
-
- case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
- {
- value = ( GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
- break;
- }
-
- case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
- {
- value = ( GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
- break;
- }
-
- case Dali::Actor::Property::PADDING:
- {
- Vector2 widthPadding = GetPadding( Dimension::WIDTH );
- Vector2 heightPadding = GetPadding( Dimension::HEIGHT );
- value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
- break;
- }
-
- case Dali::Actor::Property::MINIMUM_SIZE:
- {
- value = Vector2( GetMinimumSize( Dimension::WIDTH ), GetMinimumSize( Dimension::HEIGHT ) );
- break;
- }
-
- case Dali::Actor::Property::MAXIMUM_SIZE:
- {
- value = Vector2( GetMaximumSize( Dimension::WIDTH ), GetMaximumSize( Dimension::HEIGHT ) );
- break;
- }
-
- case Dali::Actor::Property::CLIPPING_MODE:
- {
- value = mClippingMode;
- break;
- }
-
- case Dali::DevelActor::Property::SIBLING_ORDER:
- {
- value = static_cast<int>( GetSiblingOrder() );
- break;
- }
-
- case Dali::Actor::Property::SCREEN_POSITION:
- {
- value = GetCurrentScreenPosition();
- break;
- }
-
- case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
- {
- value = mPositionUsesAnchorPoint;
- break;
- }
-
- case Dali::Actor::Property::LAYOUT_DIRECTION:
- {
- value = mLayoutDirection;
- break;
- }
-
- case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
- {
- value = IsLayoutDirectionInherited();
- break;
- }
-
- case Dali::Actor::Property::ID:
- {
- value = static_cast<int>( GetId() );
- break;
- }
-
- case Dali::Actor::Property::HIERARCHY_DEPTH:
- {
- value = GetHierarchyDepth();
- break;
- }
-
- case Dali::Actor::Property::IS_ROOT:
- {
- value = IsRoot();
- break;
- }
-
- case Dali::Actor::Property::IS_LAYER:
- {
- value = IsLayer();
- break;
- }
-
- case Dali::Actor::Property::CONNECTED_TO_SCENE:
- {
- value = OnScene();
- break;
- }
-
- case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
- {
- value = IsKeyboardFocusable();
- break;
- }
-
- case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
- {
- value = mCaptureAllTouchAfterStart;
- break;
- }
-
- default:
- {
- // Must be a scene-graph only property
- valueSet = false;
- break;
- }
- }
-
- return valueSet;
+void Actor::OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType )
+{
+ PropertyHandler::OnNotifyDefaultPropertyAnimation(*this, animation, index, value, animationType);
}
-bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const
+const PropertyBase* Actor::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
- bool valueSet = true;
-
- switch( index )
+ const PropertyBase* property = PropertyHandler::GetSceneObjectAnimatableProperty(index, GetNode());
+ if( !property )
{
- case Dali::Actor::Property::SIZE:
- {
- value = GetCurrentSize();
- break;
- }
-
- case Dali::Actor::Property::SIZE_WIDTH:
- {
- value = GetCurrentSize().width;
- break;
- }
-
- case Dali::Actor::Property::SIZE_HEIGHT:
- {
- value = GetCurrentSize().height;
- break;
- }
-
- case Dali::Actor::Property::SIZE_DEPTH:
- {
- value = GetCurrentSize().depth;
- break;
- }
-
- case Dali::Actor::Property::POSITION:
- {
- value = GetCurrentPosition();
- break;
- }
-
- case Dali::Actor::Property::POSITION_X:
- {
- value = GetCurrentPosition().x;
- break;
- }
-
- case Dali::Actor::Property::POSITION_Y:
- {
- value = GetCurrentPosition().y;
- break;
- }
-
- case Dali::Actor::Property::POSITION_Z:
- {
- value = GetCurrentPosition().z;
- break;
- }
-
- case Dali::Actor::Property::WORLD_POSITION:
- {
- value = GetCurrentWorldPosition();
- break;
- }
-
- case Dali::Actor::Property::WORLD_POSITION_X:
- {
- value = GetCurrentWorldPosition().x;
- break;
- }
-
- case Dali::Actor::Property::WORLD_POSITION_Y:
- {
- value = GetCurrentWorldPosition().y;
- break;
- }
-
- case Dali::Actor::Property::WORLD_POSITION_Z:
- {
- value = GetCurrentWorldPosition().z;
- break;
- }
-
- case Dali::Actor::Property::ORIENTATION:
- {
- value = GetCurrentOrientation();
- break;
- }
+ // not our property, ask base
+ property = Object::GetSceneObjectAnimatableProperty( index );
+ }
- case Dali::Actor::Property::WORLD_ORIENTATION:
- {
- value = GetCurrentWorldOrientation();
- break;
- }
+ return property;
+}
- case Dali::Actor::Property::SCALE:
- {
- value = GetCurrentScale();
- break;
- }
+const PropertyInputImpl* Actor::GetSceneObjectInputProperty( Property::Index index ) const
+{
+ const PropertyInputImpl* property = PropertyHandler::GetSceneObjectInputProperty(index, GetNode());
+ if( !property )
+ {
+ // reuse animatable property getter as animatable properties are inputs as well
+ // animatable property chains back to Object::GetSceneObjectInputProperty() so all properties get covered
+ property = GetSceneObjectAnimatableProperty( index );
+ }
- case Dali::Actor::Property::SCALE_X:
- {
- value = GetCurrentScale().x;
- break;
- }
+ return property;
+}
- case Dali::Actor::Property::SCALE_Y:
- {
- value = GetCurrentScale().y;
- break;
- }
+int32_t Actor::GetPropertyComponentIndex( Property::Index index ) const
+{
+ int32_t componentIndex = PropertyHandler::GetPropertyComponentIndex(index);
+ if( Property::INVALID_COMPONENT_INDEX == componentIndex )
+ {
+ // ask base
+ componentIndex = Object::GetPropertyComponentIndex( index );
+ }
- case Dali::Actor::Property::SCALE_Z:
- {
- value = GetCurrentScale().z;
- break;
- }
+ return componentIndex;
+}
- case Dali::Actor::Property::WORLD_SCALE:
- {
- value = GetCurrentWorldScale();
- break;
- }
+void Actor::SetParent( Actor* parent )
+{
+ if( parent )
+ {
+ DALI_ASSERT_ALWAYS( !mParent && "Actor cannot have 2 parents" );
- case Dali::Actor::Property::COLOR:
- {
- value = GetCurrentColor();
- break;
- }
+ mParent = parent;
- case Dali::Actor::Property::COLOR_RED:
- {
- value = GetCurrentColor().r;
- break;
- }
+ mScene = parent->mScene;
- case Dali::Actor::Property::COLOR_GREEN:
+ if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
+ parent->OnScene() )
{
- value = GetCurrentColor().g;
- break;
+ // Instruct each actor to create a corresponding node in the scene graph
+ ConnectToScene( parent->GetHierarchyDepth() );
}
- case Dali::Actor::Property::COLOR_BLUE:
- {
- value = GetCurrentColor().b;
- break;
- }
+ // Resolve the name and index for the child properties if any
+ ResolveChildProperties();
+ }
+ else // parent being set to NULL
+ {
+ DALI_ASSERT_ALWAYS( mParent != nullptr && "Actor should have a parent" );
- case Dali::Actor::Property::COLOR_ALPHA:
- case Dali::Actor::Property::OPACITY:
- {
- value = GetCurrentColor().a;
- break;
- }
+ mParent = nullptr;
- case Dali::Actor::Property::WORLD_COLOR:
+ if ( EventThreadServices::IsCoreRunning() && // Don't emit signals or send messages during Core destruction
+ OnScene() )
{
- value = GetCurrentWorldColor();
- break;
- }
+ // Disconnect the Node & its children from the scene-graph.
+ DisconnectNodeMessage( GetEventThreadServices().GetUpdateManager(), GetNode() );
- case Dali::Actor::Property::WORLD_MATRIX:
- {
- value = GetCurrentWorldMatrix();
- break;
+ // Instruct each actor to discard pointers to the scene-graph
+ DisconnectFromStage();
}
- case Dali::Actor::Property::VISIBLE:
- {
- value = IsVisible();
- break;
- }
+ mScene = nullptr;
+ }
+}
- case Dali::Actor::Property::CULLED:
- {
- value = GetNode().IsCulled( GetEventThreadServices().GetEventBufferIndex() );
- break;
- }
+bool Actor::DoAction( BaseObject* object, const std::string& actionName, const Property::Map& /* attributes */ )
+{
+ bool done = false;
+ Actor* actor = dynamic_cast< Actor* >( object );
- case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ if( actor )
+ {
+ if( 0 == actionName.compare( ACTION_SHOW ) )
{
- value = GetUpdateSizeHint();
- break;
+ actor->SetVisible( true );
+ done = true;
}
-
- default:
+ else if( 0 == actionName.compare( ACTION_HIDE ) )
{
- // Must be an event-side only property
- valueSet = false;
- break;
+ actor->SetVisible( false );
+ done = true;
}
}
- return valueSet;
+ return done;
+}
+
+Rect<> Actor::CalculateScreenExtents( ) const
+{
+ auto screenPosition = GetCurrentScreenPosition();
+ Vector3 size = GetCurrentSize() * GetCurrentWorldScale();
+ Vector3 anchorPointOffSet = size * ( mPositionUsesAnchorPoint ? GetCurrentAnchorPoint() : AnchorPoint::TOP_LEFT );
+ Vector2 position = Vector2( screenPosition.x - anchorPointOffSet.x, screenPosition.y - anchorPointOffSet.y );
+ return { position.x, position.y, size.x, size.y };
+}
+
+bool Actor::GetCachedPropertyValue( Property::Index index, Property::Value& value ) const
+{
+ return PropertyHandler::GetCachedPropertyValue(*this, index, value);
+}
+
+bool Actor::GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const
+{
+ return PropertyHandler::GetCurrentPropertyValue(*this, index, value);
}
-void Actor::EnsureRelayoutData()
+Actor::Relayouter& Actor::EnsureRelayouter()
{
- // Assign relayout data.
+ // Assign relayouter
if( !mRelayoutData )
{
- mRelayoutData = new RelayoutData();
+ mRelayoutData = new Relayouter();
}
+
+ return *mRelayoutData;
}
bool Actor::RelayoutDependentOnParent( Dimension::Type dimension )
void Actor::SetPadding( const Vector2& padding, Dimension::Type dimension )
{
- EnsureRelayoutData();
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->dimensionPadding[ i ] = padding;
- }
- }
+ EnsureRelayouter().SetPadding( padding, dimension );
}
Vector2 Actor::GetPadding( Dimension::Type dimension ) const
}
}
- return GetDefaultDimensionPadding();
+ return Relayouter::DEFAULT_DIMENSION_PADDING;
}
void Actor::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
{
- EnsureRelayoutData();
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->dimensionNegotiated[ i ] = negotiated;
- }
- }
+ EnsureRelayouter().SetLayoutNegotiated(negotiated, dimension);
}
bool Actor::IsLayoutNegotiated( Dimension::Type dimension ) const
{
- if ( mRelayoutData )
- {
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( ( dimension & ( 1 << i ) ) && mRelayoutData->dimensionNegotiated[ i ] )
- {
- return true;
- }
- }
- }
-
- return false;
+ return mRelayoutData && mRelayoutData->IsLayoutNegotiated(dimension);
}
float Actor::GetHeightForWidthBase( float width )
return 0.0f; // Default
}
-float Actor::ClampDimension( float size, Dimension::Type dimension )
-{
- const float minSize = GetMinimumSize( dimension );
- const float maxSize = GetMaximumSize( dimension );
-
- return std::max( minSize, std::min( size, maxSize ) );
-}
-
void Actor::NegotiateDimension( Dimension::Type dimension, const Vector2& allocatedSize, ActorDimensionStack& recursionStack )
{
// Check if it needs to be negotiated
OnCalculateRelayoutSize( dimension );
// All dependencies checked, calculate the size and set negotiated flag
- const float newSize = ClampDimension( CalculateSize( dimension, allocatedSize ), dimension );
+ const float newSize = Relayouter::ClampDimension( *this, CalculateSize( dimension, allocatedSize ), dimension );
SetNegotiatedDimension( newSize, dimension );
SetLayoutNegotiated( true, dimension );
Vector2 Actor::ApplySizeSetPolicy( const Vector2& size )
{
- switch( mRelayoutData->sizeSetPolicy )
- {
- case SizeScalePolicy::USE_SIZE_SET:
- {
- return size;
- }
-
- case SizeScalePolicy::FIT_WITH_ASPECT_RATIO:
- {
- // Scale size to fit within the original size bounds, keeping the natural size aspect ratio
- const Vector3 naturalSize = GetNaturalSize();
- if( naturalSize.width > 0.0f && naturalSize.height > 0.0f && size.width > 0.0f && size.height > 0.0f )
- {
- const float sizeRatio = size.width / size.height;
- const float naturalSizeRatio = naturalSize.width / naturalSize.height;
-
- if( naturalSizeRatio < sizeRatio )
- {
- return Vector2( naturalSizeRatio * size.height, size.height );
- }
- else if( naturalSizeRatio > sizeRatio )
- {
- return Vector2( size.width, size.width / naturalSizeRatio );
- }
- else
- {
- return size;
- }
- }
-
- break;
- }
-
- case SizeScalePolicy::FILL_WITH_ASPECT_RATIO:
- {
- // Scale size to fill the original size bounds, keeping the natural size aspect ratio. Potentially exceeding the original bounds.
- const Vector3 naturalSize = GetNaturalSize();
- if( naturalSize.width > 0.0f && naturalSize.height > 0.0f && size.width > 0.0f && size.height > 0.0f )
- {
- const float sizeRatio = size.width / size.height;
- const float naturalSizeRatio = naturalSize.width / naturalSize.height;
-
- if( naturalSizeRatio < sizeRatio )
- {
- return Vector2( size.width, size.width / naturalSizeRatio );
- }
- else if( naturalSizeRatio > sizeRatio )
- {
- return Vector2( naturalSizeRatio * size.height, size.height );
- }
- else
- {
- return size;
- }
- }
- break;
- }
-
- default:
- {
- break;
- }
- }
-
- return size;
+ return mRelayoutData->ApplySizeSetPolicy(*this, size);
}
void Actor::SetNegotiatedSize( RelayoutContainer& container )
{
if( mRelayoutData )
{
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->useAssignedSize[ i ] = use;
- }
- }
+ mRelayoutData->SetUseAssignedSize(use, dimension);
}
}
bool Actor::GetUseAssignedSize( Dimension::Type dimension ) const
{
- if ( mRelayoutData )
- {
- // If more than one dimension is requested, just return the first one found
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- return mRelayoutData->useAssignedSize[ i ];
- }
- }
- }
-
- return false;
+ return mRelayoutData && mRelayoutData->GetUseAssignedSize(dimension);
}
void Actor::RelayoutRequest( Dimension::Type dimension )
}
}
-void Actor::OnCalculateRelayoutSize( Dimension::Type dimension )
-{
-}
-
-void Actor::OnLayoutNegotiated( float size, Dimension::Type dimension )
-{
-}
-
void Actor::SetPreferredSize( const Vector2& size )
{
- EnsureRelayoutData();
+ EnsureRelayouter();
// If valid width or height, then set the resize policy to FIXED
// A 0 width or height may also be required so if the resize policy has not been changed, i.e. is still set to DEFAULT,
return Vector2( mRelayoutData->preferredSize );
}
- return GetDefaultPreferredSize();
+ return Relayouter::DEFAULT_PREFERRED_SIZE;
}
void Actor::SetMinimumSize( float size, Dimension::Type dimension )
{
- EnsureRelayoutData();
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->minimumSize[ i ] = size;
- }
- }
-
+ EnsureRelayouter().SetMinimumSize(size, dimension);
RelayoutRequest();
}
{
if ( mRelayoutData )
{
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- return mRelayoutData->minimumSize[ i ];
- }
- }
+ return mRelayoutData->GetMinimumSize(dimension);
}
return 0.0f; // Default
void Actor::SetMaximumSize( float size, Dimension::Type dimension )
{
- EnsureRelayoutData();
-
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- mRelayoutData->maximumSize[ i ] = size;
- }
- }
-
+ EnsureRelayouter().SetMaximumSize(size, dimension);
RelayoutRequest();
}
{
if ( mRelayoutData )
{
- for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
- {
- if( dimension & ( 1 << i ) )
- {
- return mRelayoutData->maximumSize[ i ];
- }
- }
+ return mRelayoutData->GetMaximumSize(dimension);
}
return FLT_MAX; // Default
}
-Object* Actor::GetParentObject() const
-{
- return mParent;
-}
-
void Actor::SetVisibleInternal( bool visible, SendMessage::Type sendMessage )
{
if( mVisible != visible )
}
}
-void Actor::SetScene( Scene& scene )
-{
- mScene = &scene;
-}
-
-Scene& Actor::GetScene() const
-{
- return *mScene;
-}
-
void Actor::SetInheritLayoutDirection( bool inherit )
{
if( mInheritLayoutDirection != inherit )
}
}
-bool Actor::IsLayoutDirectionInherited() const
-{
- return mInheritLayoutDirection;
-}
-
void Actor::InheritLayoutDirectionRecursively( ActorPtr actor, Dali::LayoutDirection::Type direction, bool set )
{
if( actor && ( actor->mInheritLayoutDirection || set ) )
if( actor->GetChildCount() > 0 )
{
- ActorContainer& children = actor->GetChildrenInternal();
- for( ActorIter iter = children.begin(), endIter = children.end(); iter != endIter; ++iter )
+ for( ActorPtr& child : actor->GetChildrenInternal() )
{
- InheritLayoutDirectionRecursively( *iter, direction );
+ InheritLayoutDirectionRecursively( child, direction );
}
}
}
SceneGraph::NodePropertyMessage<Vector3>::Send( GetEventThreadServices(), &GetNode(), &GetNode().mUpdateSizeHint, &AnimatableProperty<Vector3>::Bake, Vector3(updateSizeHint.width, updateSizeHint.height, 0.f ) );
}
-Vector2 Actor::GetUpdateSizeHint() const
-{
- // node is being used in a separate thread, the value from the previous update is the same, set by user
- Vector3 updateSizeHint = GetNode().GetUpdateSizeHint();
- return Vector2( updateSizeHint.width, updateSizeHint.height );
-}
-
} // namespace Internal
} // namespace Dali
#include <dali/public-api/math/viewport.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/size-negotiation/relayout-container.h>
+#include <dali/internal/common/internal-constants.h>
#include <dali/internal/common/memory-pool-object-allocator.h>
#include <dali/internal/event/actors/actor-declarations.h>
#include <dali/internal/event/common/object-impl.h>
class Renderer;
class Scene;
-typedef std::vector< ActorPtr > ActorContainer;
-typedef ActorContainer::iterator ActorIter;
-typedef ActorContainer::const_iterator ActorConstIter;
+using ActorContainer = std::vector<ActorPtr>;
+using ActorIter = ActorContainer::iterator;
+using ActorConstIter = ActorContainer::const_iterator;
-typedef std::vector< RendererPtr > RendererContainer;
-typedef RendererContainer::iterator RendererIter;
+using RendererContainer = std::vector<RendererPtr>;
+using RendererIter = RendererContainer::iterator;
class ActorDepthTreeNode;
-typedef Dali::Internal::MemoryPoolObjectAllocator< ActorDepthTreeNode > DepthNodeMemoryPool;
+using DepthNodeMemoryPool = Dali::Internal::MemoryPoolObjectAllocator<ActorDepthTreeNode>;
/**
* Actor is the primary object which Dali applications interact with.
Dimension::Type dimension; ///< The dimension to hold
};
- typedef std::vector< ActorDimensionPair > ActorDimensionStack;
+ using ActorDimensionStack = std::vector<ActorDimensionPair>;
public:
* Retrieve the name of the actor.
* @return The name.
*/
- const std::string& GetName() const;
+ const std::string& GetName() const
+ {
+ return mName;
+ }
/**
* Set the name of the actor.
/**
* Query whether the actor is connected to the Scene.
*/
- bool OnScene() const;
+ bool OnScene() const
+ {
+ return mIsOnScene;
+ }
/**
* Query whether the actor has any renderers.
void SetParentOrigin( const Vector3& origin );
/**
- * Set the x component of the parent-origin
- * @param [in] x The new x value.
- */
- void SetParentOriginX( float x );
-
- /**
- * Set the y component of the parent-origin
- * @param [in] y The new y value.
- */
- void SetParentOriginY( float y );
-
- /**
- * Set the z component of the parent-origin
- * @param [in] z The new z value.
- */
- void SetParentOriginZ( float z );
-
- /**
* Retrieve the parent-origin of an actor.
* @return The parent-origin.
*/
void SetAnchorPoint( const Vector3& anchorPoint );
/**
- * Set the x component of the anchor-point.
- * @param [in] x The new x value.
- */
- void SetAnchorPointX( float x );
-
- /**
- * Set the y component of the anchor-point.
- * @param [in] y The new y value.
- */
- void SetAnchorPointY( float y );
-
- /**
- * Set the z component of the anchor-point.
- * @param [in] z The new z value.
- */
- void SetAnchorPointZ( float z );
-
- /**
* Retrieve the anchor-point of an actor.
* @return The anchor-point.
*/
* The coordinates are relative to the Actor's parent.
* @return the Actor's position.
*/
- const Vector3& GetTargetPosition() const;
+ const Vector3& GetTargetPosition() const
+ {
+ return mTargetPosition;
+ }
/**
* @copydoc Dali::Actor::GetCurrentWorldPosition()
/**
* @copydoc Dali::Actor::IsPositionInherited()
*/
- bool IsPositionInherited() const;
+ bool IsPositionInherited() const
+ {
+ return mInheritPosition;
+ }
/**
* Sets the orientation of the Actor.
* Returns whether the actor inherit's it's parent's orientation.
* @return true if the actor inherit's it's parent orientation, false if it uses world orientation.
*/
- bool IsOrientationInherited() const;
+ bool IsOrientationInherited() const
+ {
+ return mInheritOrientation;
+ }
/**
* Sets the factor of the parents size used for the child actor.
/**
* @copydoc Dali::Actor::IsScaleInherited()
*/
- bool IsScaleInherited() const;
+ bool IsScaleInherited() const
+ {
+ return mInheritScale;
+ }
/**
* @copydoc Dali::Actor::GetCurrentWorldMatrix()
* Retrieve the actor's clipping mode.
* @return The actor's clipping mode (cached)
*/
- ClippingMode::Type GetClippingMode() const;
+ ClippingMode::Type GetClippingMode() const
+ {
+ return mClippingMode;
+ }
/**
* Sets whether an actor should emit touch or hover signals; see SignalTouch() and SignalHover().
/**
* @copydoc Dali::Actor::GetDrawMode
*/
- DrawMode::Type GetDrawMode() const;
+ DrawMode::Type GetDrawMode() const
+ {
+ return mDrawMode;
+ }
/**
* @copydoc Dali::Actor::IsOverlay
*/
- bool IsOverlay() const;
+ bool IsOverlay() const
+ {
+ return ( DrawMode::OVERLAY_2D == mDrawMode );
+ }
/**
* Sets the actor's color. The final color of actor depends on its color mode.
* Returns the actor's color mode.
* @return currently used colorMode.
*/
- ColorMode GetColorMode() const;
+ ColorMode GetColorMode() const
+ {
+ return mColorMode;
+ }
/**
* @copydoc Dali::Actor::GetCurrentWorldColor()
*
* @return The depth used for hit-testing and renderer sorting
*/
- uint32_t GetSortingDepth();
+ uint32_t GetSortingDepth()
+ {
+ return mSortedDepth;
+ }
public:
*
* @param dimension The dimension that is about to be calculated
*/
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension );
+ virtual void OnCalculateRelayoutSize( Dimension::Type dimension ) {}
/**
* @brief Virtual method to notify deriving classes that the size for a dimension
* @param[in] size The new size for the given dimension
* @param[in] dimension The dimension that was just negotiated
*/
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension );
+ virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ) {}
/**
* @brief Determine if this actor is dependent on it's children for relayout
float CalculateSize( Dimension::Type dimension, const Vector2& maximumSize );
/**
- * @brief Clamp a dimension given the relayout constraints on this actor
- *
- * @param[in] size The size to constrain
- * @param[in] dimension The dimension the size exists in
- * @return Return the clamped size
- */
- float ClampDimension( float size, Dimension::Type dimension );
-
- /**
* Negotiate a dimension based on the size of the parent
*
* @param[in] dimension The dimension to negotiate on
float screenY ) const;
/**
- * Performs a ray-sphere test with the given pick-ray and the actor's bounding sphere.
- * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
- * @param[in] rayOrigin The ray origin in the world's reference system.
- * @param[in] rayDir The ray director vector in the world's reference system.
- * @return True if the ray intersects the actor's bounding sphere.
- */
- bool RaySphereTest( const Vector4& rayOrigin, const Vector4& rayDir ) const;
-
- /**
- * Performs a ray-actor test with the given pick-ray and the actor's geometry.
- * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
- * @param[in] rayOrigin The ray origin in the world's reference system.
- * @param[in] rayDir The ray director vector in the world's reference system.
- * @param[out] hitPointLocal The hit point in the Actor's local reference system.
- * @param[out] distance The distance from the hit point to the camera.
- * @return True if the ray intersects the actor's geometry.
- */
- bool RayActorTest( const Vector4& rayOrigin,
- const Vector4& rayDir,
- Vector2& hitPointLocal,
- float& distance ) const;
-
- /**
* Sets whether the actor should receive a notification when touch or hover motion events leave
* the boundary of the actor.
*
*
* @param[in] required Should be set to true if a Leave event is required
*/
- void SetLeaveRequired( bool required );
+ void SetLeaveRequired( bool required )
+ {
+ mLeaveRequired = required;
+ }
/**
* This returns whether the actor requires touch or hover events whenever touch or hover motion events leave
* the boundary of the actor.
* @return true if a Leave event is required, false otherwise.
*/
- bool GetLeaveRequired() const;
+ bool GetLeaveRequired() const
+ {
+ return mLeaveRequired;
+ }
/**
* @copydoc Dali::Actor::SetKeyboardFocusable()
*/
- void SetKeyboardFocusable( bool focusable );
+ void SetKeyboardFocusable( bool focusable )
+ {
+ mKeyboardFocusable = focusable;
+ }
/**
* @copydoc Dali::Actor::IsKeyboardFocusable()
*/
- bool IsKeyboardFocusable() const;
+ bool IsKeyboardFocusable() const
+ {
+ return mKeyboardFocusable;
+ }
/**
* Query whether the application or derived actor type requires touch events.
* @return True if touch events are required.
*/
- bool GetTouchRequired() const;
+ bool GetTouchRequired() const
+ {
+ return !mTouchedSignal.Empty();
+ }
/**
* Query whether the application or derived actor type requires hover events.
* @return True if hover events are required.
*/
- bool GetHoverRequired() const;
+ bool GetHoverRequired() const
+ {
+ return !mHoveredSignal.Empty();
+ }
/**
* Query whether the application or derived actor type requires wheel events.
* @return True if wheel events are required.
*/
- bool GetWheelEventRequired() const;
+ bool GetWheelEventRequired() const
+ {
+ return !mWheelEventSignal.Empty();
+ }
/**
* Query whether the actor is actually hittable. This method checks whether the actor is
* sensitive, has the visibility flag set to true and is not fully transparent.
* @return true, if it can be hit, false otherwise.
*/
- bool IsHittable() const;
+ bool IsHittable() const
+ {
+ return IsSensitive() && IsVisible() && ( GetCurrentWorldColor().a > FULLY_TRANSPARENT ) && IsNodeConnected();
+ }
/**
* Query whether the actor captures all touch after it starts even if touch leaves its boundary.
/**
* @copydoc Dali::Actor::TouchedSignal()
*/
- Dali::Actor::TouchEventSignalType& TouchedSignal();
+ Dali::Actor::TouchEventSignalType& TouchedSignal()
+ {
+ return mTouchedSignal;
+ }
/**
* @copydoc Dali::Actor::HoveredSignal()
*/
- Dali::Actor::HoverSignalType& HoveredSignal();
+ Dali::Actor::HoverSignalType& HoveredSignal()
+ {
+ return mHoveredSignal;
+ }
/**
* @copydoc Dali::Actor::WheelEventSignal()
*/
- Dali::Actor::WheelEventSignalType& WheelEventSignal();
+ Dali::Actor::WheelEventSignalType& WheelEventSignal()
+ {
+ return mWheelEventSignal;
+ }
/**
* @copydoc Dali::Actor::OnSceneSignal()
*/
- Dali::Actor::OnSceneSignalType& OnSceneSignal();
+ Dali::Actor::OnSceneSignalType& OnSceneSignal()
+ {
+ return mOnSceneSignal;
+ }
/**
* @copydoc Dali::Actor::OffSceneSignal()
*/
- Dali::Actor::OffSceneSignalType& OffSceneSignal();
+ Dali::Actor::OffSceneSignalType& OffSceneSignal()
+ {
+ return mOffSceneSignal;
+ }
/**
* @copydoc Dali::Actor::OnRelayoutSignal()
*/
- Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal();
+ Dali::Actor::OnRelayoutSignalType& OnRelayoutSignal()
+ {
+ return mOnRelayoutSignal;
+ }
/**
* @copydoc DevelActor::VisibilityChangedSignal
*/
- DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal();
+ DevelActor::VisibilityChangedSignalType& VisibilityChangedSignal()
+ {
+ return mVisibilityChangedSignal;
+ }
/**
* @copydoc LayoutDirectionChangedSignal
*/
- Dali::Actor::LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal();
+ Dali::Actor::LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal()
+ {
+ return mLayoutDirectionChangedSignal;
+ }
/**
* @copydoc DevelActor::ChildAddedSignal
*/
- DevelActor::ChildChangedSignalType& ChildAddedSignal();
+ DevelActor::ChildChangedSignalType& ChildAddedSignal()
+ {
+ return mChildAddedSignal;
+ }
/**
* @copydoc DevelActor::ChildRemovedSignal
*/
- DevelActor::ChildChangedSignalType& ChildRemovedSignal();
+ DevelActor::ChildChangedSignalType& ChildRemovedSignal()
+ {
+ return mChildRemovedSignal;
+ }
/**
* @copydoc DevelActor::ChildOrderChangedSignal
*/
- DevelActor::ChildOrderChangedSignalType& ChildOrderChangedSignal();
+ DevelActor::ChildOrderChangedSignalType& ChildOrderChangedSignal()
+ {
+ return mChildOrderChangedSignal;
+ }
/**
* Connects a callback function with the object's signals.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Actor();
+ ~Actor() override;
/**
* Called on a child during Add() when the parent actor is connected to the Scene.
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* @copydoc Dali::Internal::Object::SetSceneGraphProperty()
*/
- virtual void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value );
+ void SetSceneGraphProperty( Property::Index index, const PropertyMetadata& entry, const Property::Value& value ) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetPropertyComponentIndex()
*/
- virtual int32_t GetPropertyComponentIndex( Property::Index index ) const;
+ int32_t GetPropertyComponentIndex( Property::Index index ) const override;
+
+ /**
+ * @copydoc Dali::Internal::Object::IsAnimationPossible()
+ */
+ bool IsAnimationPossible() const override
+ {
+ return OnScene();
+ }
/**
* Retrieve the actor's node.
* Sets the scene which this actor is added to.
* @param[in] scene The scene
*/
- void SetScene( Scene& scene );
+ void SetScene( Scene& scene )
+ {
+ mScene = &scene;
+ }
/**
* Gets the scene which this actor is added to.
* @return The scene
*/
- Scene& GetScene() const;
+ Scene& GetScene() const
+ {
+ return *mScene;
+ }
private:
};
};
+ struct Relayouter;
+
// Remove default constructor and copy constructor
Actor() = delete;
Actor( const Actor& ) = delete;
bool GetCurrentPropertyValue( Property::Index index, Property::Value& value ) const;
/**
- * @brief Ensure the relayout data is allocated
+ * @brief Ensure the relayouter is allocated
*/
- void EnsureRelayoutData();
+ Relayouter& EnsureRelayouter();
/**
* @brief Apply the size set policy to the input size
* Retrieve the parent object of an Actor.
* @return The parent object, or NULL if the Actor does not have a parent.
*/
- virtual Object* GetParentObject() const;
+ Object* GetParentObject() const override
+ {
+ return mParent;
+ }
/**
* Set Sibling order
* Returns whether the actor inherits it's parent's layout direction.
* @return true if the actor inherits it's parent's layout direction, false otherwise.
*/
- bool IsLayoutDirectionInherited() const;
+ bool IsLayoutDirectionInherited() const
+ {
+ return mInheritLayoutDirection;
+ }
/**
* @brief Propagates layout direction recursively.
*/
void SetUpdateSizeHint( const Vector2& updateSizeHint );
- /**
- * @brief Return the update size hint of actor
- * @return Return the update size hint
- */
- Vector2 GetUpdateSizeHint() const;
-
protected:
Scene* mScene; ///< The scene the actor is added to
Vector3* mParentOrigin; ///< NULL means ParentOrigin::DEFAULT. ParentOrigin is non-animatable
Vector3* mAnchorPoint; ///< NULL means AnchorPoint::DEFAULT. AnchorPoint is non-animatable
- struct RelayoutData;
- RelayoutData* mRelayoutData; ///< Struct to hold optional collection of relayout variables
+ Relayouter* mRelayoutData; ///< Struct to hold optional collection of relayout variables
ActorGestureData* mGestureData; ///< Optional Gesture data. Only created when actor requires gestures
static ActorContainer mNullChildren; ///< Empty container (shared by all actors, returned by GetChildren() const)
+ struct PropertyHandler;
};
} // namespace Internal
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/actors/actor-property-handler.h>
+
+// INTERNAL INCLUDES
+#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/math/vector3.h>
+#include <dali/devel-api/actors/actor-devel.h>
+#include <dali/internal/event/actors/actor-impl.h>
+#include <dali/internal/event/common/property-helper.h>
+#include <dali/internal/update/nodes/node-messages.h>
+#include <dali/internal/update/nodes/node-declarations.h>
+
+using Dali::Internal::SceneGraph::Node;
+using Dali::Internal::SceneGraph::AnimatableProperty;
+using Dali::Internal::SceneGraph::PropertyBase;
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+namespace // unnamed namespace
+{
+
+struct AnchorValue
+{
+ const char* name;
+ const Vector3& value;
+};
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN_WITH_TYPE( AnchorValue, ANCHOR_CONSTANT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_LEFT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_CENTER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, TOP_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_LEFT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, CENTER_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_LEFT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_CENTER )
+DALI_ENUM_TO_STRING_WITH_SCOPE( AnchorPoint, BOTTOM_RIGHT )
+DALI_ENUM_TO_STRING_TABLE_END( ANCHOR_CONSTANT )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( COLOR_MODE )
+DALI_ENUM_TO_STRING( USE_OWN_COLOR )
+DALI_ENUM_TO_STRING( USE_PARENT_COLOR )
+DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_COLOR )
+DALI_ENUM_TO_STRING( USE_OWN_MULTIPLY_PARENT_ALPHA )
+DALI_ENUM_TO_STRING_TABLE_END( COLOR_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( DRAW_MODE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, NORMAL )
+DALI_ENUM_TO_STRING_WITH_SCOPE( DrawMode, OVERLAY_2D )
+DALI_ENUM_TO_STRING_TABLE_END( DRAW_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( RESIZE_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIXED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_NATURAL_SIZE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FILL_TO_PARENT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_RELATIVE_TO_PARENT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, SIZE_FIXED_OFFSET_FROM_PARENT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, FIT_TO_CHILDREN )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, DIMENSION_DEPENDENCY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ResizePolicy, USE_ASSIGNED_SIZE )
+DALI_ENUM_TO_STRING_TABLE_END( RESIZE_POLICY )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( SIZE_SCALE_POLICY )
+DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, USE_SIZE_SET )
+DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FIT_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING_WITH_SCOPE( SizeScalePolicy, FILL_WITH_ASPECT_RATIO )
+DALI_ENUM_TO_STRING_TABLE_END( SIZE_SCALE_POLICY )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( CLIPPING_MODE )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, DISABLED )
+DALI_ENUM_TO_STRING_WITH_SCOPE( ClippingMode, CLIP_CHILDREN )
+DALI_ENUM_TO_STRING_TABLE_END( CLIPPING_MODE )
+
+DALI_ENUM_TO_STRING_TABLE_BEGIN( LAYOUT_DIRECTION )
+DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, LEFT_TO_RIGHT )
+DALI_ENUM_TO_STRING_WITH_SCOPE( LayoutDirection, RIGHT_TO_LEFT )
+DALI_ENUM_TO_STRING_TABLE_END( LAYOUT_DIRECTION )
+
+bool GetAnchorPointConstant( const std::string& value, Vector3& anchor )
+{
+ for( uint32_t i = 0; i < ANCHOR_CONSTANT_TABLE_COUNT; ++i )
+ {
+ uint32_t sizeIgnored = 0;
+ if( CompareTokens( value.c_str(), ANCHOR_CONSTANT_TABLE[ i ].name, sizeIgnored ) )
+ {
+ anchor = ANCHOR_CONSTANT_TABLE[ i ].value;
+ return true;
+ }
+ }
+ return false;
+}
+
+inline bool GetParentOriginConstant( const std::string& value, Vector3& parentOrigin )
+{
+ // Values are the same so just use the same table as anchor-point
+ return GetAnchorPointConstant( value, parentOrigin );
+}
+
+} // unnamed namespace
+
+void Actor::PropertyHandler::SetDefaultProperty( Internal::Actor& actor, Property::Index index, const Property::Value& property )
+{
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
+ {
+ actor.SetParentOrigin( property.Get< Vector3 >() );
+ }
+ else if ( type == Property::STRING )
+ {
+ std::string parentOriginString;
+ property.Get( parentOriginString );
+ Vector3 parentOrigin;
+ if( GetParentOriginConstant( parentOriginString, parentOrigin ) )
+ {
+ actor.SetParentOrigin( parentOrigin );
+ }
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ {
+ const Vector3& current = actor.GetCurrentParentOrigin();
+ actor.SetParentOrigin( Vector3( property.Get< float >(), current.y, current.z ) );
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ {
+ const Vector3& current = actor.GetCurrentParentOrigin();
+ actor.SetParentOrigin( Vector3( current.x, property.Get< float >(), current.z ) );
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ {
+ const Vector3& current = actor.GetCurrentParentOrigin();
+ actor.SetParentOrigin( Vector3( current.x, current.y, property.Get< float >() ) );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
+ {
+ actor.SetAnchorPoint( property.Get< Vector3 >() );
+ }
+ else if ( type == Property::STRING )
+ {
+ std::string anchorPointString;
+ property.Get( anchorPointString );
+ Vector3 anchor;
+ if( GetAnchorPointConstant( anchorPointString, anchor ) )
+ {
+ actor.SetAnchorPoint( anchor );
+ }
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ {
+ const Vector3& current = actor.GetCurrentAnchorPoint();
+ actor.SetAnchorPoint( Vector3( property.Get< float >(), current.y, current.z ) );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ {
+ const Vector3& current = actor.GetCurrentAnchorPoint();
+ actor.SetAnchorPoint( Vector3( current.x, property.Get< float >(), current.z ) );
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ {
+ const Vector3& current = actor.GetCurrentAnchorPoint();
+ actor.SetAnchorPoint( Vector3( current.x, current.y, property.Get< float >() ) );
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR2 )
+ {
+ actor.SetSize( property.Get< Vector2 >() );
+ }
+ else if ( type == Property::VECTOR3 )
+ {
+ actor.SetSize( property.Get< Vector3 >() );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ actor.SetWidth( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ actor.SetHeight( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ actor.SetDepth( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR2 )
+ {
+ Vector2 position = property.Get< Vector2 >();
+ actor.SetPosition( Vector3( position.x, position.y, 0.0f ) );
+ }
+ else if ( type == Property::VECTOR3 )
+ {
+ actor.SetPosition( property.Get< Vector3 >() );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ actor.SetX( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ actor.SetY( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ actor.SetZ( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ actor.SetOrientation( property.Get< Quaternion >() );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::FLOAT )
+ {
+ float scale = property.Get< float >();
+ actor.SetScale( scale, scale, scale );
+ }
+ else if ( type == Property::VECTOR3 )
+ {
+ actor.SetScale( property.Get< Vector3 >() );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_X:
+ {
+ actor.SetScaleX( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ actor.SetScaleY( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ actor.SetScaleZ( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ actor.SetVisible( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR:
+ {
+ Property::Type type = property.GetType();
+ if( type == Property::VECTOR3 )
+ {
+ Vector3 color = property.Get< Vector3 >();
+ actor.SetColor( Vector4( color.r, color.g, color.b, 1.0f ) );
+ }
+ else if( type == Property::VECTOR4 )
+ {
+ actor.SetColor( property.Get< Vector4 >() );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ actor.SetColorRed( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ actor.SetColorGreen( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ actor.SetColorBlue( property.Get< float >() );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::OPACITY:
+ {
+ float value;
+ if( property.Get( value ) )
+ {
+ actor.SetOpacity( value );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::NAME:
+ {
+ actor.SetName( property.Get< std::string >() );
+ break;
+ }
+
+ case Dali::Actor::Property::SENSITIVE:
+ {
+ actor.SetSensitive( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::LEAVE_REQUIRED:
+ {
+ actor.SetLeaveRequired( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ actor.SetInheritPosition( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
+ {
+ actor.SetInheritOrientation( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_SCALE:
+ {
+ actor.SetInheritScale( property.Get< bool >() );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_MODE:
+ {
+ ColorMode mode = actor.mColorMode;
+ if ( Scripting::GetEnumerationProperty< ColorMode >( property, COLOR_MODE_TABLE, COLOR_MODE_TABLE_COUNT, mode ) )
+ {
+ actor.SetColorMode( mode );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::DRAW_MODE:
+ {
+ DrawMode::Type mode = actor.mDrawMode;
+ if( Scripting::GetEnumerationProperty< DrawMode::Type >( property, DRAW_MODE_TABLE, DRAW_MODE_TABLE_COUNT, mode ) )
+ {
+ actor.SetDrawMode( mode );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_MODE_FACTOR:
+ {
+ actor.SetSizeModeFactor( property.Get< Vector3 >() );
+ break;
+ }
+
+ case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
+ {
+ ResizePolicy::Type type = actor.GetResizePolicy( Dimension::WIDTH );
+ if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
+ {
+ actor.SetResizePolicy( type, Dimension::WIDTH );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
+ {
+ ResizePolicy::Type type = actor.GetResizePolicy( Dimension::HEIGHT );
+ if( Scripting::GetEnumerationProperty< ResizePolicy::Type >( property, RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT, type ) )
+ {
+ actor.SetResizePolicy( type, Dimension::HEIGHT );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_SCALE_POLICY:
+ {
+ SizeScalePolicy::Type type = actor.GetSizeScalePolicy();
+ if( Scripting::GetEnumerationProperty< SizeScalePolicy::Type >( property, SIZE_SCALE_POLICY_TABLE, SIZE_SCALE_POLICY_TABLE_COUNT, type ) )
+ {
+ actor.SetSizeScalePolicy( type );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
+ {
+ if( property.Get< bool >() )
+ {
+ actor.SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::WIDTH );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
+ {
+ if( property.Get< bool >() )
+ {
+ actor.SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY, Dimension::HEIGHT );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::PADDING:
+ {
+ Vector4 padding = property.Get< Vector4 >();
+ actor.SetPadding( Vector2( padding.x, padding.y ), Dimension::WIDTH );
+ actor.SetPadding( Vector2( padding.z, padding.w ), Dimension::HEIGHT );
+ break;
+ }
+
+ case Dali::Actor::Property::MINIMUM_SIZE:
+ {
+ Vector2 size = property.Get< Vector2 >();
+ actor.SetMinimumSize( size.x, Dimension::WIDTH );
+ actor.SetMinimumSize( size.y, Dimension::HEIGHT );
+ break;
+ }
+
+ case Dali::Actor::Property::MAXIMUM_SIZE:
+ {
+ Vector2 size = property.Get< Vector2 >();
+ actor.SetMaximumSize( size.x, Dimension::WIDTH );
+ actor.SetMaximumSize( size.y, Dimension::HEIGHT );
+ break;
+ }
+
+ case Dali::DevelActor::Property::SIBLING_ORDER:
+ {
+ int value;
+
+ if( property.Get( value ) )
+ {
+ actor.SetSiblingOrder( value );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::CLIPPING_MODE:
+ {
+ ClippingMode::Type convertedValue = actor.mClippingMode;
+ if( Scripting::GetEnumerationProperty< ClippingMode::Type >( property, CLIPPING_MODE_TABLE, CLIPPING_MODE_TABLE_COUNT, convertedValue ) )
+ {
+ actor.mClippingMode = convertedValue;
+ SetClippingModeMessage( actor.GetEventThreadServices(), actor.GetNode(), actor.mClippingMode );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
+ {
+ bool value = false;
+ if( property.Get( value ) && value != actor.mPositionUsesAnchorPoint )
+ {
+ actor.mPositionUsesAnchorPoint = value;
+ SetPositionUsesAnchorPointMessage( actor.GetEventThreadServices(), actor.GetNode(), actor.mPositionUsesAnchorPoint );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ Dali::LayoutDirection::Type direction = actor.mLayoutDirection;
+ actor.mInheritLayoutDirection = false;
+
+ if( Scripting::GetEnumerationProperty< LayoutDirection::Type >( property, LAYOUT_DIRECTION_TABLE, LAYOUT_DIRECTION_TABLE_COUNT, direction ) )
+ {
+ actor.InheritLayoutDirectionRecursively( &actor, direction, true );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ bool value = false;
+ if( property.Get( value ) )
+ {
+ actor.SetInheritLayoutDirection( value );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
+ {
+ bool value = false;
+ if( property.Get( value ) )
+ {
+ actor.SetKeyboardFocusable( value );
+ }
+ break;
+ }
+
+ case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ {
+ actor.SetUpdateSizeHint( property.Get< Vector2 >() );
+ break;
+ }
+
+ case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
+ {
+ bool boolValue = false;
+ if ( property.Get( boolValue ) )
+ {
+ actor.mCaptureAllTouchAfterStart = boolValue;
+ }
+ break;
+ }
+
+ default:
+ {
+ // this can happen in the case of a non-animatable default property so just do nothing
+ break;
+ }
+ }
+}
+
+void Actor::PropertyHandler::SetSceneGraphProperty(
+ Property::Index index,
+ const PropertyMetadata& entry,
+ const Property::Value& value,
+ EventThreadServices& eventThreadServices,
+ const SceneGraph::Node& node)
+{
+ switch( entry.GetType() )
+ {
+ case Property::BOOLEAN:
+ {
+ const AnimatableProperty< bool >* property = dynamic_cast< const AnimatableProperty< bool >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<bool>::Send( eventThreadServices, &node, property, &AnimatableProperty<bool>::Bake, value.Get<bool>() );
+
+ break;
+ }
+
+ case Property::INTEGER:
+ {
+ const AnimatableProperty< int >* property = dynamic_cast< const AnimatableProperty< int >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<int>::Send( eventThreadServices, &node, property, &AnimatableProperty<int>::Bake, value.Get<int>() );
+
+ break;
+ }
+
+ case Property::FLOAT:
+ {
+ const AnimatableProperty< float >* property = dynamic_cast< const AnimatableProperty< float >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<float>::Send( eventThreadServices, &node, property, &AnimatableProperty<float>::Bake, value.Get<float>() );
+
+ break;
+ }
+
+ case Property::VECTOR2:
+ {
+ const AnimatableProperty< Vector2 >* property = dynamic_cast< const AnimatableProperty< Vector2 >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector2>::BakeX, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 1)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector2>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector2>::BakeY, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector2>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector2>::Bake, value.Get<Vector2>() );
+ }
+
+ break;
+ }
+
+ case Property::VECTOR3:
+ {
+ const AnimatableProperty< Vector3 >* property = dynamic_cast< const AnimatableProperty< Vector3 >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeX, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 1)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeY, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 2)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::BakeZ, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector3>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector3>::Bake, value.Get<Vector3>() );
+ }
+
+ break;
+ }
+
+ case Property::VECTOR4:
+ {
+ const AnimatableProperty< Vector4 >* property = dynamic_cast< const AnimatableProperty< Vector4 >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ if(entry.componentIndex == 0)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeX, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 1)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeY, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 2)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeZ, value.Get<float>() );
+ }
+ else if(entry.componentIndex == 3)
+ {
+ SceneGraph::NodePropertyComponentMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::BakeW, value.Get<float>() );
+ }
+ else
+ {
+ SceneGraph::NodePropertyMessage<Vector4>::Send( eventThreadServices, &node, property, &AnimatableProperty<Vector4>::Bake, value.Get<Vector4>() );
+ }
+
+ break;
+ }
+
+ case Property::ROTATION:
+ {
+ const AnimatableProperty< Quaternion >* property = dynamic_cast< const AnimatableProperty< Quaternion >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Quaternion>::Send( eventThreadServices, &node, property,&AnimatableProperty<Quaternion>::Bake, value.Get<Quaternion>() );
+
+ break;
+ }
+
+ case Property::MATRIX:
+ {
+ const AnimatableProperty< Matrix >* property = dynamic_cast< const AnimatableProperty< Matrix >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Matrix>::Send( eventThreadServices, &node, property,&AnimatableProperty<Matrix>::Bake, value.Get<Matrix>() );
+
+ break;
+ }
+
+ case Property::MATRIX3:
+ {
+ const AnimatableProperty< Matrix3 >* property = dynamic_cast< const AnimatableProperty< Matrix3 >* >( entry.GetSceneGraphProperty() );
+ DALI_ASSERT_DEBUG( NULL != property );
+
+ // property is being used in a separate thread; queue a message to set the property
+ SceneGraph::NodePropertyMessage<Matrix3>::Send( eventThreadServices, &node, property,&AnimatableProperty<Matrix3>::Bake, value.Get<Matrix3>() );
+
+ break;
+ }
+
+ default:
+ {
+ // nothing to do for other types
+ }
+ } // entry.GetType
+}
+
+void Actor::PropertyHandler::OnNotifyDefaultPropertyAnimation(Internal::Actor& actor, Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType)
+{
+ switch( animationType )
+ {
+ case Animation::TO:
+ case Animation::BETWEEN:
+ {
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ if( value.Get( actor.mTargetSize ) )
+ {
+ actor.mAnimatedSize = actor.mTargetSize;
+ actor.mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ if( value.Get( actor.mTargetSize.width ) )
+ {
+ actor.mAnimatedSize.width = actor.mTargetSize.width;
+ actor.mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ if( value.Get( actor.mTargetSize.height ) )
+ {
+ actor.mAnimatedSize.height = actor.mTargetSize.height;
+ actor.mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ if( value.Get( actor.mTargetSize.depth ) )
+ {
+ actor.mAnimatedSize.depth = actor.mTargetSize.depth;
+ actor.mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ value.Get( actor.mTargetPosition );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value.Get( actor.mTargetPosition.x );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value.Get( actor.mTargetPosition.y );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ value.Get( actor.mTargetPosition.z );
+ break;
+ }
+
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ value.Get( actor.mTargetOrientation );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE:
+ {
+ value.Get( actor.mTargetScale );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value.Get( actor.mTargetScale.x );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value.Get( actor.mTargetScale.y );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value.Get( actor.mTargetScale.z );
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ actor.SetVisibleInternal( value.Get< bool >(), SendMessage::FALSE );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR:
+ {
+ value.Get( actor.mTargetColor );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value.Get( actor.mTargetColor.r );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value.Get( actor.mTargetColor.g );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value.Get( actor.mTargetColor.b );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::OPACITY:
+ {
+ value.Get( actor.mTargetColor.a );
+ break;
+ }
+
+ default:
+ {
+ // Not an animatable property. Do nothing.
+ break;
+ }
+ }
+ break;
+ }
+
+ case Animation::BY:
+ {
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ if( AdjustValue< Vector3 >( actor.mTargetSize, value ) )
+ {
+ actor.mAnimatedSize = actor.mTargetSize;
+ actor.mUseAnimatedSize = AnimatedSizeFlag::WIDTH | AnimatedSizeFlag::HEIGHT | AnimatedSizeFlag::DEPTH;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ if( AdjustValue< float >( actor.mTargetSize.width, value ) )
+ {
+ actor.mAnimatedSize.width = actor.mTargetSize.width;
+ actor.mUseAnimatedSize |= AnimatedSizeFlag::WIDTH;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ if( AdjustValue< float >( actor.mTargetSize.height, value ) )
+ {
+ actor.mAnimatedSize.height = actor.mTargetSize.height;
+ actor.mUseAnimatedSize |= AnimatedSizeFlag::HEIGHT;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ if( AdjustValue< float >( actor.mTargetSize.depth, value ) )
+ {
+ actor.mAnimatedSize.depth = actor.mTargetSize.depth;
+ actor.mUseAnimatedSize |= AnimatedSizeFlag::DEPTH;
+
+ // Notify deriving classes
+ actor.OnSizeAnimation( animation, actor.mTargetSize );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ AdjustValue< Vector3 >( actor.mTargetPosition, value );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ AdjustValue< float >( actor.mTargetPosition.x, value );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ AdjustValue< float >( actor.mTargetPosition.y, value );
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ AdjustValue< float >( actor.mTargetPosition.z, value );
+ break;
+ }
+
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ Quaternion relativeValue;
+ if( value.Get( relativeValue ) )
+ {
+ actor.mTargetOrientation *= relativeValue;
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE:
+ {
+ AdjustValue< Vector3 >( actor.mTargetScale, value );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_X:
+ {
+ AdjustValue< float >( actor.mTargetScale.x, value );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ AdjustValue< float >( actor.mTargetScale.y, value );
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ AdjustValue< float >( actor.mTargetScale.z, value );
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ bool relativeValue = false;
+ if( value.Get( relativeValue ) )
+ {
+ bool visible = actor.mVisible || relativeValue;
+ actor.SetVisibleInternal( visible, SendMessage::FALSE );
+ }
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR:
+ {
+ AdjustValue< Vector4 >( actor.mTargetColor, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ AdjustValue< float >( actor.mTargetColor.r, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ AdjustValue< float >( actor.mTargetColor.g, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ AdjustValue< float >( actor.mTargetColor.b, value );
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::OPACITY:
+ {
+ AdjustValue< float >( actor.mTargetColor.a, value );
+ break;
+ }
+
+ default:
+ {
+ // Not an animatable property. Do nothing.
+ break;
+ }
+ }
+ break;
+ }
+ }
+}
+
+const PropertyBase* Actor::PropertyHandler::GetSceneObjectAnimatableProperty(Property::Index index, const SceneGraph::Node& node)
+{
+ const PropertyBase* property( nullptr );
+
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE: // FALLTHROUGH
+ case Dali::Actor::Property::SIZE_WIDTH: // FALLTHROUGH
+ case Dali::Actor::Property::SIZE_HEIGHT: // FALLTHROUGH
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ property = &node.mSize;
+ break;
+ }
+ case Dali::Actor::Property::POSITION: // FALLTHROUGH
+ case Dali::Actor::Property::POSITION_X: // FALLTHROUGH
+ case Dali::Actor::Property::POSITION_Y: // FALLTHROUGH
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ property = &node.mPosition;
+ break;
+ }
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ property = &node.mOrientation;
+ break;
+ }
+ case Dali::Actor::Property::SCALE: // FALLTHROUGH
+ case Dali::Actor::Property::SCALE_X: // FALLTHROUGH
+ case Dali::Actor::Property::SCALE_Y: // FALLTHROUGH
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ property = &node.mScale;
+ break;
+ }
+ case Dali::Actor::Property::VISIBLE:
+ {
+ property = &node.mVisible;
+ break;
+ }
+ case Dali::Actor::Property::COLOR: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_RED: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_GREEN: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_BLUE: // FALLTHROUGH
+ case Dali::Actor::Property::COLOR_ALPHA: // FALLTHROUGH
+ case Dali::Actor::Property::OPACITY:
+ {
+ property = &node.mColor;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ return property;
+}
+
+const PropertyInputImpl* Actor::PropertyHandler::GetSceneObjectInputProperty(Property::Index index, const SceneGraph::Node& node)
+{
+ const PropertyInputImpl* property( nullptr );
+
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN: // FALLTHROUGH
+ case Dali::Actor::Property::PARENT_ORIGIN_X: // FALLTHROUGH
+ case Dali::Actor::Property::PARENT_ORIGIN_Y: // FALLTHROUGH
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ {
+ property = &node.mParentOrigin;
+ break;
+ }
+ case Dali::Actor::Property::ANCHOR_POINT: // FALLTHROUGH
+ case Dali::Actor::Property::ANCHOR_POINT_X: // FALLTHROUGH
+ case Dali::Actor::Property::ANCHOR_POINT_Y: // FALLTHROUGH
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ {
+ property = &node.mAnchorPoint;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_POSITION: // FALLTHROUGH
+ case Dali::Actor::Property::WORLD_POSITION_X: // FALLTHROUGH
+ case Dali::Actor::Property::WORLD_POSITION_Y: // FALLTHROUGH
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ {
+ property = &node.mWorldPosition;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_ORIENTATION:
+ {
+ property = &node.mWorldOrientation;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_SCALE:
+ {
+ property = &node.mWorldScale;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_COLOR:
+ {
+ property = &node.mWorldColor;
+ break;
+ }
+ case Dali::Actor::Property::WORLD_MATRIX:
+ {
+ property = &node.mWorldMatrix;
+ break;
+ }
+ case Dali::Actor::Property::CULLED:
+ {
+ property = &node.mCulled;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ return property;
+}
+
+int32_t Actor::PropertyHandler::GetPropertyComponentIndex(Property::Index index)
+{
+ int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;
+
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ case Dali::Actor::Property::SIZE_WIDTH:
+ case Dali::Actor::Property::POSITION_X:
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ case Dali::Actor::Property::SCALE_X:
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ componentIndex = 0;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ case Dali::Actor::Property::POSITION_Y:
+ case Dali::Actor::Property::WORLD_POSITION_Y:
+ case Dali::Actor::Property::SCALE_Y:
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ componentIndex = 1;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ case Dali::Actor::Property::SIZE_DEPTH:
+ case Dali::Actor::Property::POSITION_Z:
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ case Dali::Actor::Property::SCALE_Z:
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ componentIndex = 2;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::OPACITY:
+ {
+ componentIndex = 3;
+ break;
+ }
+
+ default:
+ {
+ // Do nothing
+ break;
+ }
+ }
+
+ return componentIndex;
+}
+
+bool Actor::PropertyHandler::GetCachedPropertyValue(const Internal::Actor& actor, Property::Index index, Property::Value& value)
+{
+ bool valueSet = true;
+
+ switch( index )
+ {
+ case Dali::Actor::Property::PARENT_ORIGIN:
+ {
+ value = actor.GetCurrentParentOrigin();
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_X:
+ {
+ value = actor.GetCurrentParentOrigin().x;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Y:
+ {
+ value = actor.GetCurrentParentOrigin().y;
+ break;
+ }
+
+ case Dali::Actor::Property::PARENT_ORIGIN_Z:
+ {
+ value = actor.GetCurrentParentOrigin().z;
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT:
+ {
+ value = actor.GetCurrentAnchorPoint();
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_X:
+ {
+ value = actor.GetCurrentAnchorPoint().x;
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Y:
+ {
+ value = actor.GetCurrentAnchorPoint().y;
+ break;
+ }
+
+ case Dali::Actor::Property::ANCHOR_POINT_Z:
+ {
+ value = actor.GetCurrentAnchorPoint().z;
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE:
+ {
+ value = actor.GetTargetSize();
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ value = actor.GetTargetSize().width;
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ value = actor.GetTargetSize().height;
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ value = actor.GetTargetSize().depth;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ value = actor.GetTargetPosition();
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value = actor.GetTargetPosition().x;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value = actor.GetTargetPosition().y;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ value = actor.GetTargetPosition().z;
+ break;
+ }
+
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ value = actor.mTargetOrientation;
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE:
+ {
+ value = actor.mTargetScale;
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value = actor.mTargetScale.x;
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value = actor.mTargetScale.y;
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value = actor.mTargetScale.z;
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ value = actor.mVisible;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR:
+ {
+ value = actor.mTargetColor;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value = actor.mTargetColor.r;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value = actor.mTargetColor.g;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value = actor.mTargetColor.b;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::OPACITY:
+ {
+ value = actor.mTargetColor.a;
+ break;
+ }
+
+ case Dali::Actor::Property::NAME:
+ {
+ value = actor.GetName();
+ break;
+ }
+
+ case Dali::Actor::Property::SENSITIVE:
+ {
+ value = actor.IsSensitive();
+ break;
+ }
+
+ case Dali::Actor::Property::LEAVE_REQUIRED:
+ {
+ value = actor.GetLeaveRequired();
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_POSITION:
+ {
+ value = actor.IsPositionInherited();
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_ORIENTATION:
+ {
+ value = actor.IsOrientationInherited();
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_SCALE:
+ {
+ value = actor.IsScaleInherited();
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_MODE:
+ {
+ value = actor.GetColorMode();
+ break;
+ }
+
+ case Dali::Actor::Property::DRAW_MODE:
+ {
+ value = actor.GetDrawMode();
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_MODE_FACTOR:
+ {
+ value = actor.GetSizeModeFactor();
+ break;
+ }
+
+ case Dali::Actor::Property::WIDTH_RESIZE_POLICY:
+ {
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( actor.GetResizePolicy( Dimension::WIDTH ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+ break;
+ }
+
+ case Dali::Actor::Property::HEIGHT_RESIZE_POLICY:
+ {
+ value = Scripting::GetLinearEnumerationName< ResizePolicy::Type >( actor.GetResizePolicy( Dimension::HEIGHT ), RESIZE_POLICY_TABLE, RESIZE_POLICY_TABLE_COUNT );
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_SCALE_POLICY:
+ {
+ value = actor.GetSizeScalePolicy();
+ break;
+ }
+
+ case Dali::Actor::Property::WIDTH_FOR_HEIGHT:
+ {
+ value = ( actor.GetResizePolicy( Dimension::WIDTH ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( actor.GetDimensionDependency( Dimension::WIDTH ) == Dimension::HEIGHT );
+ break;
+ }
+
+ case Dali::Actor::Property::HEIGHT_FOR_WIDTH:
+ {
+ value = ( actor.GetResizePolicy( Dimension::HEIGHT ) == ResizePolicy::DIMENSION_DEPENDENCY ) && ( actor.GetDimensionDependency( Dimension::HEIGHT ) == Dimension::WIDTH );
+ break;
+ }
+
+ case Dali::Actor::Property::PADDING:
+ {
+ Vector2 widthPadding = actor.GetPadding( Dimension::WIDTH );
+ Vector2 heightPadding = actor.GetPadding( Dimension::HEIGHT );
+ value = Vector4( widthPadding.x, widthPadding.y, heightPadding.x, heightPadding.y );
+ break;
+ }
+
+ case Dali::Actor::Property::MINIMUM_SIZE:
+ {
+ value = Vector2( actor.GetMinimumSize( Dimension::WIDTH ), actor.GetMinimumSize( Dimension::HEIGHT ) );
+ break;
+ }
+
+ case Dali::Actor::Property::MAXIMUM_SIZE:
+ {
+ value = Vector2( actor.GetMaximumSize( Dimension::WIDTH ), actor.GetMaximumSize( Dimension::HEIGHT ) );
+ break;
+ }
+
+ case Dali::Actor::Property::CLIPPING_MODE:
+ {
+ value = actor.mClippingMode;
+ break;
+ }
+
+ case Dali::DevelActor::Property::SIBLING_ORDER:
+ {
+ value = static_cast<int>( actor.GetSiblingOrder() );
+ break;
+ }
+
+ case Dali::Actor::Property::SCREEN_POSITION:
+ {
+ value = actor.GetCurrentScreenPosition();
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_USES_ANCHOR_POINT:
+ {
+ value = actor.mPositionUsesAnchorPoint;
+ break;
+ }
+
+ case Dali::Actor::Property::LAYOUT_DIRECTION:
+ {
+ value = actor.mLayoutDirection;
+ break;
+ }
+
+ case Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION:
+ {
+ value = actor.IsLayoutDirectionInherited();
+ break;
+ }
+
+ case Dali::Actor::Property::ID:
+ {
+ value = static_cast<int>( actor.GetId() );
+ break;
+ }
+
+ case Dali::Actor::Property::HIERARCHY_DEPTH:
+ {
+ value = actor.GetHierarchyDepth();
+ break;
+ }
+
+ case Dali::Actor::Property::IS_ROOT:
+ {
+ value = actor.IsRoot();
+ break;
+ }
+
+ case Dali::Actor::Property::IS_LAYER:
+ {
+ value = actor.IsLayer();
+ break;
+ }
+
+ case Dali::Actor::Property::CONNECTED_TO_SCENE:
+ {
+ value = actor.OnScene();
+ break;
+ }
+
+ case Dali::Actor::Property::KEYBOARD_FOCUSABLE:
+ {
+ value = actor.IsKeyboardFocusable();
+ break;
+ }
+
+ case Dali::DevelActor::Property::CAPTURE_ALL_TOUCH_AFTER_START:
+ {
+ value = actor.mCaptureAllTouchAfterStart;
+ break;
+ }
+
+ default:
+ {
+ // Must be a scene-graph only property
+ valueSet = false;
+ break;
+ }
+ }
+
+ return valueSet;
+}
+
+bool Actor::PropertyHandler::GetCurrentPropertyValue(const Internal::Actor& actor, Property::Index index, Property::Value& value)
+{
+ bool valueSet = true;
+
+ switch( index )
+ {
+ case Dali::Actor::Property::SIZE:
+ {
+ value = actor.GetCurrentSize();
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_WIDTH:
+ {
+ value = actor.GetCurrentSize().width;
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_HEIGHT:
+ {
+ value = actor.GetCurrentSize().height;
+ break;
+ }
+
+ case Dali::Actor::Property::SIZE_DEPTH:
+ {
+ value = actor.GetCurrentSize().depth;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION:
+ {
+ value = actor.GetCurrentPosition();
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_X:
+ {
+ value = actor.GetCurrentPosition().x;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Y:
+ {
+ value = actor.GetCurrentPosition().y;
+ break;
+ }
+
+ case Dali::Actor::Property::POSITION_Z:
+ {
+ value = actor.GetCurrentPosition().z;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION:
+ {
+ value = actor.GetCurrentWorldPosition();
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION_X:
+ {
+ value = actor.GetCurrentWorldPosition().x;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION_Y:
+ {
+ value = actor.GetCurrentWorldPosition().y;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_POSITION_Z:
+ {
+ value = actor.GetCurrentWorldPosition().z;
+ break;
+ }
+
+ case Dali::Actor::Property::ORIENTATION:
+ {
+ value = actor.GetCurrentOrientation();
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_ORIENTATION:
+ {
+ value = actor.GetCurrentWorldOrientation();
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE:
+ {
+ value = actor.GetCurrentScale();
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_X:
+ {
+ value = actor.GetCurrentScale().x;
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Y:
+ {
+ value = actor.GetCurrentScale().y;
+ break;
+ }
+
+ case Dali::Actor::Property::SCALE_Z:
+ {
+ value = actor.GetCurrentScale().z;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_SCALE:
+ {
+ value = actor.GetCurrentWorldScale();
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR:
+ {
+ value = actor.GetCurrentColor();
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_RED:
+ {
+ value = actor.GetCurrentColor().r;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_GREEN:
+ {
+ value = actor.GetCurrentColor().g;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_BLUE:
+ {
+ value = actor.GetCurrentColor().b;
+ break;
+ }
+
+ case Dali::Actor::Property::COLOR_ALPHA:
+ case Dali::Actor::Property::OPACITY:
+ {
+ value = actor.GetCurrentColor().a;
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_COLOR:
+ {
+ value = actor.GetCurrentWorldColor();
+ break;
+ }
+
+ case Dali::Actor::Property::WORLD_MATRIX:
+ {
+ value = actor.GetCurrentWorldMatrix();
+ break;
+ }
+
+ case Dali::Actor::Property::VISIBLE:
+ {
+ value = actor.IsVisible();
+ break;
+ }
+
+ case Dali::Actor::Property::CULLED:
+ {
+ value = actor.GetNode().IsCulled( actor.GetEventThreadServices().GetEventBufferIndex() );
+ break;
+ }
+
+ case Dali::DevelActor::Property::UPDATE_SIZE_HINT:
+ {
+ // node is being used in a separate thread, the value from the previous update is the same, set by user
+ value = Vector2( actor.GetNode().GetUpdateSizeHint() );
+ break;
+ }
+
+ default:
+ {
+ // Must be an event-side only property
+ valueSet = false;
+ break;
+ }
+ }
+
+ return valueSet;
+}
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_ACTOR_PROPERTY_HANDLER_H
+#define DALI_INTERNAL_ACTOR_PROPERTY_HANDLER_H
+
+
+/*
+ * Copyright (c) 2020 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/internal/event/actors/actor-impl.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+/**
+ * Extracts out the property related methods from Actor
+ */
+struct Actor::PropertyHandler
+{
+ using PropertyBase = Dali::Internal::SceneGraph::PropertyBase;
+
+ /// @copydoc Actor::SetDefaultProperty
+ static void SetDefaultProperty(
+ Internal::Actor& actor,
+ Property::Index index,
+ const Property::Value& property);
+
+ /// @copydoc Actor::SetSceneGraphProperty
+ static void SetSceneGraphProperty(
+ Property::Index index,
+ const PropertyMetadata& entry,
+ const Property::Value& value,
+ EventThreadServices& eventThreadServices,
+ const SceneGraph::Node& node);
+
+ /// @copydoc Actor::OnNotifyDefaultPropertyAnimation
+ static void OnNotifyDefaultPropertyAnimation(
+ Internal::Actor& actor,
+ Animation& animation,
+ Property::Index index,
+ const Property::Value& value,
+ Animation::Type animationType);
+
+ /// @copydoc Actor::GetSceneObjectAnimatableProperty
+ static const PropertyBase* GetSceneObjectAnimatableProperty(
+ Property::Index index,
+ const SceneGraph::Node& node);
+
+ /// @copydoc Actor::GetSceneObjectInputProperty
+ static const PropertyInputImpl* GetSceneObjectInputProperty(
+ Property::Index index,
+ const SceneGraph::Node& node);
+
+ /// @copydoc Actor::GetPropertyComponentIndex
+ static int32_t GetPropertyComponentIndex(Property::Index index);
+
+ /// @copydoc Actor::GetCachedPropertyValue
+ static bool GetCachedPropertyValue(
+ const Internal::Actor& actor,
+ Property::Index index,
+ Property::Value& value);
+
+ /// @copydoc Actor::GetCurrentPropertyValue
+ static bool GetCurrentPropertyValue(
+ const Internal::Actor& actor,
+ Property::Index index,
+ Property::Value& value);
+};
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_ACTOR_PROPERTY_HANDLER_H
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/actors/actor-relayouter.h>
+
+// INTERNAL INCLUDES
+#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/math/vector3.h>
+#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+Actor::Relayouter::Relayouter()
+: sizeModeFactor( DEFAULT_SIZE_MODE_FACTOR ),
+ preferredSize( DEFAULT_PREFERRED_SIZE ),
+ sizeSetPolicy( DEFAULT_SIZE_SCALE_POLICY ),
+ relayoutEnabled( false ),
+ insideRelayout( false )
+{
+ // Set size negotiation defaults
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ resizePolicies[ i ] = ResizePolicy::DEFAULT;
+ useAssignedSize[ i ] = false;
+ negotiatedDimensions[ i ] = 0.0f;
+ dimensionNegotiated[ i ] = false;
+ dimensionDirty[ i ] = false;
+ dimensionDependencies[ i ] = Dimension::ALL_DIMENSIONS;
+ dimensionPadding[ i ] = DEFAULT_DIMENSION_PADDING;
+ minimumSize[ i ] = 0.0f;
+ maximumSize[ i ] = FLT_MAX;
+ }
+}
+
+ResizePolicy::Type Actor::Relayouter::GetResizePolicy( Dimension::Type dimension ) const
+{
+ // If more than one dimension is requested, just return the first one found
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ if( useAssignedSize[ i ] )
+ {
+ return ResizePolicy::USE_ASSIGNED_SIZE;
+ }
+ else
+ {
+ return resizePolicies[ i ];
+ }
+ }
+ }
+
+ return ResizePolicy::DEFAULT;
+}
+
+void Actor::Relayouter::SetPadding( const Vector2& padding, Dimension::Type dimension )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ dimensionPadding[ i ] = padding;
+ }
+ }
+}
+
+void Actor::Relayouter::SetLayoutNegotiated( bool negotiated, Dimension::Type dimension )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ dimensionNegotiated[ i ] = negotiated;
+ }
+ }
+}
+
+bool Actor::Relayouter::IsLayoutNegotiated( Dimension::Type dimension ) const
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) && dimensionNegotiated[ i ] )
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+Vector2 Actor::Relayouter::ApplySizeSetPolicy( Internal::Actor& actor, const Vector2& size )
+{
+ switch( sizeSetPolicy )
+ {
+ case SizeScalePolicy::USE_SIZE_SET:
+ {
+ return size;
+ }
+
+ case SizeScalePolicy::FIT_WITH_ASPECT_RATIO:
+ {
+ // Scale size to fit within the original size bounds, keeping the natural size aspect ratio
+ const Vector3 naturalSize = actor.GetNaturalSize();
+ if( naturalSize.width > 0.0f && naturalSize.height > 0.0f && size.width > 0.0f && size.height > 0.0f )
+ {
+ const float sizeRatio = size.width / size.height;
+ const float naturalSizeRatio = naturalSize.width / naturalSize.height;
+
+ if( naturalSizeRatio < sizeRatio )
+ {
+ return Vector2( naturalSizeRatio * size.height, size.height );
+ }
+ else if( naturalSizeRatio > sizeRatio )
+ {
+ return Vector2( size.width, size.width / naturalSizeRatio );
+ }
+ else
+ {
+ return size;
+ }
+ }
+
+ break;
+ }
+
+ case SizeScalePolicy::FILL_WITH_ASPECT_RATIO:
+ {
+ // Scale size to fill the original size bounds, keeping the natural size aspect ratio. Potentially exceeding the original bounds.
+ const Vector3 naturalSize = actor.GetNaturalSize();
+ if( naturalSize.width > 0.0f && naturalSize.height > 0.0f && size.width > 0.0f && size.height > 0.0f )
+ {
+ const float sizeRatio = size.width / size.height;
+ const float naturalSizeRatio = naturalSize.width / naturalSize.height;
+
+ if( naturalSizeRatio < sizeRatio )
+ {
+ return Vector2( size.width, size.width / naturalSizeRatio );
+ }
+ else if( naturalSizeRatio > sizeRatio )
+ {
+ return Vector2( naturalSizeRatio * size.height, size.height );
+ }
+ else
+ {
+ return size;
+ }
+ }
+ break;
+ }
+
+ default:
+ {
+ break;
+ }
+ }
+
+ return size;
+}
+
+void Actor::Relayouter::SetUseAssignedSize( bool use, Dimension::Type dimension )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ useAssignedSize[ i ] = use;
+ }
+ }
+}
+
+bool Actor::Relayouter::GetUseAssignedSize( Dimension::Type dimension ) const
+{
+ // If more than one dimension is requested, just return the first one found
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return useAssignedSize[ i ];
+ }
+ }
+
+ return false;
+}
+
+void Actor::Relayouter::SetMinimumSize( float size, Dimension::Type dimension )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ minimumSize[ i ] = size;
+ }
+ }
+}
+
+float Actor::Relayouter::GetMinimumSize( Dimension::Type dimension ) const
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return minimumSize[ i ];
+ }
+ }
+
+ return 0.0f; // Default
+}
+
+void Actor::Relayouter::SetMaximumSize( float size, Dimension::Type dimension )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ maximumSize[ i ] = size;
+ }
+ }
+}
+
+float Actor::Relayouter::GetMaximumSize( Dimension::Type dimension ) const
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ return maximumSize[ i ];
+ }
+ }
+
+ return FLT_MAX; // Default
+}
+
+void Actor::Relayouter::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension, Vector3& targetSize )
+{
+ ResizePolicy::Type originalWidthPolicy = GetResizePolicy(Dimension::WIDTH);
+ ResizePolicy::Type originalHeightPolicy = GetResizePolicy(Dimension::HEIGHT);
+
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ if ( policy == ResizePolicy::USE_ASSIGNED_SIZE )
+ {
+ useAssignedSize[ i ] = true;
+ }
+ else
+ {
+ resizePolicies[ i ] = policy;
+ useAssignedSize[ i ] = false;
+ }
+ }
+ }
+
+ if( policy == ResizePolicy::DIMENSION_DEPENDENCY )
+ {
+ if( dimension & Dimension::WIDTH )
+ {
+ SetDimensionDependency( Dimension::WIDTH, Dimension::HEIGHT );
+ }
+
+ if( dimension & Dimension::HEIGHT )
+ {
+ SetDimensionDependency( Dimension::HEIGHT, Dimension::WIDTH );
+ }
+ }
+
+ // If calling SetResizePolicy, assume we want relayout enabled
+ relayoutEnabled = true;
+
+ // If the resize policy is set to be FIXED, the preferred size
+ // should be overrided by the target size. Otherwise the target
+ // size should be overrided by the preferred size.
+
+ if( dimension & Dimension::WIDTH )
+ {
+ if( originalWidthPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
+ {
+ preferredSize.width = targetSize.width;
+ }
+ else if( originalWidthPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
+ {
+ targetSize.width = preferredSize.width;
+ }
+ }
+
+ if( dimension & Dimension::HEIGHT )
+ {
+ if( originalHeightPolicy != ResizePolicy::FIXED && policy == ResizePolicy::FIXED )
+ {
+ preferredSize.height = targetSize.height;
+ }
+ else if( originalHeightPolicy == ResizePolicy::FIXED && policy != ResizePolicy::FIXED )
+ {
+ targetSize.height = preferredSize.height;
+ }
+ }
+}
+
+void Actor::Relayouter::SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ dimensionDependencies[ i ] = dependency;
+ }
+ }
+}
+
+Dimension::Type Actor::Relayouter::GetDimensionDependency( Dimension::Type dimension ) const
+{
+ // If more than one dimension is requested, just return the first one found
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) )
+ {
+ return dimensionDependencies[ i ];
+ }
+ }
+
+ return Dimension::ALL_DIMENSIONS; // Default
+}
+
+void Actor::Relayouter::SetLayoutDirty( bool dirty, Dimension::Type dimension )
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( dimension & ( 1 << i ) )
+ {
+ dimensionDirty[ i ] = dirty;
+ }
+ }
+}
+
+bool Actor::Relayouter::IsLayoutDirty( Dimension::Type dimension ) const
+{
+ for( uint32_t i = 0; i < Dimension::DIMENSION_COUNT; ++i )
+ {
+ if( ( dimension & ( 1 << i ) ) && dimensionDirty[ i ] )
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+float Actor::Relayouter::ClampDimension( const Internal::Actor& actor, float size, Dimension::Type dimension )
+{
+ const float minSize = actor.GetMinimumSize( dimension );
+ const float maxSize = actor.GetMaximumSize( dimension );
+
+ return std::max( minSize, std::min( size, maxSize ) );
+}
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_ACTOR_RELAYOUTER_H
+#define DALI_INTERNAL_ACTOR_RELAYOUTER_H
+
+/*
+ * Copyright (c) 2020 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/public-api/math/vector2.h>
+#include <dali/public-api/math/vector3.h>
+#include <dali/internal/event/actors/actor-impl.h>
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+/**
+ * Struct to do some actor specific relayouting and store related variables
+ */
+struct Actor::Relayouter
+{
+ // Defaults
+ static constexpr Vector3 DEFAULT_SIZE_MODE_FACTOR{1.0f, 1.0f, 1.0f};
+ static constexpr Vector2 DEFAULT_PREFERRED_SIZE{0.0f, 0.0f};
+ static constexpr Vector2 DEFAULT_DIMENSION_PADDING{0.0f, 0.0f};
+ static constexpr SizeScalePolicy::Type DEFAULT_SIZE_SCALE_POLICY = SizeScalePolicy::USE_SIZE_SET;
+
+ /// Constructor
+ Relayouter();
+
+ /// Default Destructor
+ ~Relayouter() = default;
+
+ /// @copydoc Actor::GetResizePolicy
+ ResizePolicy::Type GetResizePolicy( Dimension::Type dimension ) const;
+
+ /// @copydoc Actor::SetPadding
+ void SetPadding( const Vector2& padding, Dimension::Type dimension );
+
+ /// @copydoc Actor::SetLayoutNegotiated
+ void SetLayoutNegotiated( bool negotiated, Dimension::Type dimension );
+
+ /// @copydoc Actor::IsLayoutNegotiated
+ bool IsLayoutNegotiated( Dimension::Type dimension ) const;
+
+ /// @copydoc Actor::ApplySizeSetPolicy
+ Vector2 ApplySizeSetPolicy( Internal::Actor& actor, const Vector2& size );
+
+ /// @copydoc Actor::SetUseAssignedSize
+ void SetUseAssignedSize( bool use, Dimension::Type dimension );
+
+ /// @copydoc Actor::GetUseAssignedSize
+ bool GetUseAssignedSize( Dimension::Type dimension ) const;
+
+ /// @copydoc Actor::SetMinimumSize
+ void SetMinimumSize( float size, Dimension::Type dimension );
+
+ /// @copydoc Actor::GetMinimumSize
+ float GetMinimumSize( Dimension::Type dimension ) const;
+
+ /// @copydoc Actor::SetMaximumSize
+ void SetMaximumSize( float size, Dimension::Type dimension );
+
+ /// @copydoc Actor::GetMaximumSize
+ float GetMaximumSize( Dimension::Type dimension ) const;
+
+ /// @copydoc Actor::SetResizePolicy
+ void SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension, Vector3& targetSize );
+
+ /// @copydoc Actor::SetDimensionDependency
+ void SetDimensionDependency( Dimension::Type dimension, Dimension::Type dependency );
+
+ /// @copydoc Actor::GetDimensionDependency
+ Dimension::Type GetDimensionDependency( Dimension::Type dimension ) const;
+
+ /// @copydoc Actor::SetLayoutDirty
+ void SetLayoutDirty( bool dirty, Dimension::Type dimension );
+
+ /// @copydoc Actor::IsLayoutDirty
+ bool IsLayoutDirty( Dimension::Type dimension ) const;
+
+ /**
+ * @brief Clamp a dimension given the relayout constraints on given actor
+ *
+ * @param[in] actor The actor to clamp
+ * @param[in] size The size to constrain
+ * @param[in] dimension The dimension the size exists in
+ * @return Return the clamped size
+ */
+ static float ClampDimension( const Internal::Actor& actor, float size, Dimension::Type dimension );
+
+public:
+
+ ResizePolicy::Type resizePolicies[ Dimension::DIMENSION_COUNT ]; ///< Resize policies
+ bool useAssignedSize[ Dimension::DIMENSION_COUNT ]; ///< The flag to specify whether the size should be assigned to the actor
+
+ Dimension::Type dimensionDependencies[ Dimension::DIMENSION_COUNT ]; ///< A list of dimension dependencies
+
+ Vector2 dimensionPadding[ Dimension::DIMENSION_COUNT ]; ///< Padding for each dimension. X = start (e.g. left, bottom), y = end (e.g. right, top)
+
+ float negotiatedDimensions[ Dimension::DIMENSION_COUNT ]; ///< Storage for when a dimension is negotiated but before set on actor
+
+ float minimumSize[ Dimension::DIMENSION_COUNT ]; ///< The minimum size an actor can be
+ float maximumSize[ Dimension::DIMENSION_COUNT ]; ///< The maximum size an actor can be
+
+ bool dimensionNegotiated[ Dimension::DIMENSION_COUNT ]; ///< Has the dimension been negotiated
+ bool dimensionDirty[ Dimension::DIMENSION_COUNT ]; ///< Flags indicating whether the layout dimension is dirty or not
+
+ Vector3 sizeModeFactor; ///< Factor of size used for certain SizeModes
+
+ Vector2 preferredSize; ///< The preferred size of the actor
+
+ SizeScalePolicy::Type sizeSetPolicy :3; ///< Policy to apply when setting size. Enough room for the enum
+
+ bool relayoutEnabled :1; ///< Flag to specify if this actor should be included in size negotiation or not (defaults to true)
+ bool insideRelayout :1; ///< Locking flag to prevent recursive relayouts on size set
+};
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_ACTOR_RELAYOUTER_H
CameraActor::CameraActor( const SceneGraph::Node& node )
: Actor( Actor::BASIC, node ),
- mSceneObject( NULL ),
+ mSceneObject( nullptr ),
mTarget( SceneGraph::Camera::DEFAULT_TARGET_POSITION ),
mType( SceneGraph::Camera::DEFAULT_TYPE ),
mProjectionMode( SceneGraph::Camera::DEFAULT_MODE ),
const PropertyInputImpl* CameraActor::GetSceneObjectInputProperty( Property::Index index ) const
{
- const PropertyInputImpl* property( NULL );
+ const PropertyInputImpl* property( nullptr );
switch( index )
{
/**
* copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetDefaultProperty( Property::Index index, const Property::Value& propertyValue ) override;
/**
* copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~CameraActor();
+ ~CameraActor() override;
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~CustomActor();
+ ~CustomActor() override;
private:
/**
* @copydoc Internal::Actor::OnSceneConnectionExternal
*/
- virtual void OnSceneConnectionExternal( int32_t depth )
+ void OnSceneConnectionExternal( int32_t depth ) override
{
mImpl->OnSceneConnection( depth );
}
/**
* @copydoc Internal::Actor::OnSceneDisconnectionExternal
*/
- virtual void OnSceneDisconnectionExternal()
+ void OnSceneDisconnectionExternal() override
{
mImpl->OnSceneDisconnection();
}
/**
* @copydoc Internal::Actor::OnChildAdd
*/
- virtual void OnChildAdd(Actor& child)
+ void OnChildAdd(Actor& child) override
{
Dali::Actor handle(&child);
mImpl->OnChildAdd(handle);
/**
* @copydoc Internal::Actor::OnChildRemove
*/
- virtual void OnChildRemove(Actor& child)
+ void OnChildRemove(Actor& child) override
{
Dali::Actor handle(&child);
mImpl->OnChildRemove(handle);
/**
* @copydoc Internal::Actor::OnPropertySet
*/
- virtual void OnPropertySet( Property::Index index, const Property::Value& propertyValue )
+ void OnPropertySet( Property::Index index, const Property::Value& propertyValue ) override
{
mImpl->OnPropertySet(index, propertyValue);
}
/**
* @copydoc Internal::Actor::OnSizeSet
*/
- virtual void OnSizeSet(const Vector3& targetSize)
+ void OnSizeSet(const Vector3& targetSize) override
{
mImpl->OnSizeSet(targetSize);
}
/**
* @copydoc Internal::Actor::OnSizeAnimation
*/
- virtual void OnSizeAnimation(Animation& animation, const Vector3& targetSize)
+ void OnSizeAnimation(Animation& animation, const Vector3& targetSize) override
{
Dali::Animation animationHandle(&animation);
mImpl->OnSizeAnimation(animationHandle, targetSize);
/**
* @copydoc Internal::Actor::OnRelayout
*/
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container )
+ void OnRelayout( const Vector2& size, RelayoutContainer& container ) override
{
mImpl->OnRelayout( size, container );
}
/**
* @copydoc Internal::Actor::OnSetResizePolicy
*/
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+ void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) override
{
mImpl->OnSetResizePolicy( policy, dimension );
}
/**
* @copydoc Internal::Actor::GetNaturalSize
*/
- virtual Vector3 GetNaturalSize() const
+ Vector3 GetNaturalSize() const override
{
return mImpl->GetNaturalSize();
}
/**
* @copydoc Internal::Actor::CalculateChildSize
*/
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension )
+ float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) override
{
return mImpl->CalculateChildSize( child, dimension );
}
/**
* @copydoc Internal::Actor::GetHeightForWidth
*/
- virtual float GetHeightForWidth( float width )
+ float GetHeightForWidth( float width ) override
{
return mImpl->GetHeightForWidth( width );
}
/**
* @copydoc Internal::Actor::GetWidthForHeight
*/
- virtual float GetWidthForHeight( float height )
+ float GetWidthForHeight( float height ) override
{
return mImpl->GetWidthForHeight( height );
}
/**
* @copydoc Internal::Actor::RelayoutDependentOnChildren
*/
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS )
+ bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) override
{
return mImpl->RelayoutDependentOnChildren( dimension );
}
/**
* @copydoc Internal::Actor::OnCalculateRelayoutSize
*/
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension )
+ void OnCalculateRelayoutSize( Dimension::Type dimension ) override
{
return mImpl->OnCalculateRelayoutSize( dimension );
}
/**
* @copydoc Internal::Actor::OnLayoutNegotiated
*/
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension )
+ void OnLayoutNegotiated( float size, Dimension::Type dimension ) override
{
return mImpl->OnLayoutNegotiated( size, dimension );
}
Layer::Layer( Actor::DerivedType type, const SceneGraph::Layer& layer )
: Actor( type, layer ),
- mLayerList( NULL ),
+ mLayerList( nullptr ),
mClippingBox( 0, 0, 0, 0 ),
mSortFunction( Layer::ZValue ),
mBehavior( Dali::Layer::LAYER_UI ),
DALI_ASSERT_DEBUG( NULL == mLayerList );
// Find the ordered layer-list
- for ( Actor* parent = mParent; parent != NULL; parent = parent->GetParent() )
+ for ( Actor* parent = mParent; parent != nullptr; parent = parent->GetParent() )
{
if( parent->IsLayer() )
{
mLayerList->UnregisterLayer(*this);
// mLayerList is only valid when on-stage
- mLayerList = NULL;
+ mLayerList = nullptr;
}
const SceneGraph::Layer& Layer::GetSceneGraphLayer() const
class Layer;
}
-typedef Dali::ClippingBox ClippingBox;
+using ClippingBox = Dali::ClippingBox;
class Layer : public Actor
{
/**
* @copydoc Dali::Internal::Actor::OnInitialize
*/
- void OnInitialize();
+ void OnInitialize() override;
/**
* Query the current depth of the layer
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Layer();
+ ~Layer() override;
private: // From Actor
/**
* From Actor.
*/
- virtual void OnSceneConnectionInternal();
+ void OnSceneConnectionInternal() override;
/**
* From Actor.
*/
- virtual void OnSceneDisconnectionInternal();
+ void OnSceneDisconnectionInternal() override;
private:
{
typedef std::vector<Layer*> LayerContainer;
-typedef LayerContainer::iterator LayerIter;
-typedef LayerContainer::reverse_iterator ReverseLayerIter;
+using LayerIter = LayerContainer::iterator;
+using ReverseLayerIter = LayerContainer::reverse_iterator;
/**
* A private helper template to return an iterator to the layer passed in.
LayerList::LayerList( SceneGraph::UpdateManager& updateManager )
: mUpdateManager( updateManager ),
- mRoot( NULL )
+ mRoot( nullptr )
{
}
Layer* mRoot; ///< The root layer that this ordered list of layers belong to
- typedef std::vector<Layer*> LayerContainer;
+ using LayerContainer = std::vector<Layer*>;
// Layers are not owned by the LayerList.
// Each layer is responsible for registering & unregistering before the end of its life-time.
}
Animation::Animation( EventThreadServices& eventThreadServices, AnimationPlaylist& playlist, float durationSeconds, EndAction endAction, EndAction disconnectAction, AlphaFunction defaultAlpha )
-: mAnimation( NULL ),
+: mAnimation( nullptr ),
mEventThreadServices( eventThreadServices ),
mPlaylist( playlist ),
mFinishedSignal(),
void Animation::DestroySceneObject()
{
- if ( mAnimation != NULL )
+ if ( mAnimation != nullptr )
{
// Remove animation using a message to the update manager
RemoveAnimationMessage( mEventThreadServices.GetUpdateManager(), *mAnimation );
- mAnimation = NULL;
+ mAnimation = nullptr;
}
}
AnimatorConnectorBase* connector = mConnectors[ iter->connectorIndex ];
Object* object = connector->GetObject();
- if( object )
+ if(object && object->IsAnimationPossible())
{
const auto propertyIndex = connector->GetPropertyIndex();
object->NotifyPropertyAnimation(
class Object;
class Path;
-typedef IntrusivePtr<Animation> AnimationPtr;
-typedef std::vector<AnimationPtr> AnimationContainer;
+using AnimationPtr = IntrusivePtr<Animation>;
+using AnimationContainer = std::vector<AnimationPtr>;
-typedef AnimationContainer::iterator AnimationIter;
-typedef AnimationContainer::const_iterator AnimationConstIter;
+using AnimationIter = AnimationContainer::iterator;
+using AnimationConstIter = AnimationContainer::const_iterator;
/**
* Animation is a proxy for a SceneGraph::Animation object.
BETWEEN ///< Animating BETWEEN key-frames
};
- typedef Dali::Animation::EndAction EndAction;
- typedef Dali::Animation::Interpolation Interpolation;
+ using EndAction = Dali::Animation::EndAction;
+ using Interpolation = Dali::Animation::Interpolation;
/**
* Create a new Animation object.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Animation();
+ ~Animation() override;
private:
Dali::Animation::AnimationSignalType mProgressReachedSignal;
- typedef OwnerContainer< AnimatorConnectorBase* > AnimatorConnectorContainer;
+ using AnimatorConnectorContainer = OwnerContainer<AnimatorConnectorBase*>;
AnimatorConnectorContainer mConnectors; ///< Owned by the Animation
- typedef std::vector< ConnectorTargetValues > ConnectorTargetValuesContainer;
+ using ConnectorTargetValuesContainer = std::vector<ConnectorTargetValues>;
ConnectorTargetValuesContainer mConnectorTargetValues; //< Used to store animating property target value information
Vector2 mPlayRange;
class AnimationPlaylist;
-typedef OwnerPointer<AnimationPlaylist> AnimationPlaylistOwner;
+using AnimationPlaylistOwner = OwnerPointer<AnimationPlaylist>;
} // namespace Internal
/**
* Virtual destructor.
*/
- virtual ~AnimationPlaylist();
+ ~AnimationPlaylist() override;
/**
* Called when an animation is constructed.
/**
* @copydoc CompleteNotificationInterface::NotifyCompleted()
*/
- virtual void NotifyCompleted();
+ void NotifyCompleted() override;
private:
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnectorBase()
+ ~AnimatorConnectorBase() override
{
if( mObject )
{
/**
* From Object::Observer
*/
- virtual void SceneObjectAdded( Object& object ) override final
+ void SceneObjectAdded( Object& object ) final
{
// If the animator has not been created yet, create it now.
if( !mAnimator && mObject )
/**
* From Object::Observer
*/
- virtual void SceneObjectRemoved( Object& object ) override final
+ void SceneObjectRemoved( Object& object ) final
{
}
/**
* From Object::Observer
*/
- virtual void ObjectDestroyed( Object& object )
+ void ObjectDestroyed( Object& object ) override
{
mObject = nullptr;
}
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnector()
+ ~AnimatorConnector() override
{
}
/**
* @copydoc AnimatorConnectorBase::DoCreateAnimator()
*/
- bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) override final
+ bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) final
{
bool resetterRequired = false;
// components only supported for float property type
/**
* Virtual destructor.
*/
- virtual ~AnimatorConnector()
+ ~AnimatorConnector() override
{
}
/**
* @copydoc AnimatorConnectorBase::DoCreateAnimator()
*/
- bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) override final
+ bool DoCreateAnimator( const SceneGraph::PropertyOwner& propertyOwner, const SceneGraph::PropertyBase& baseProperty ) final
{
bool resetterRequired = false;
if( mComponentIndex == Property::INVALID_COMPONENT_INDEX )
{
typedef Dali::Vector<Object*> ObjectContainer;
-typedef ObjectContainer::Iterator ObjectIter;
+using ObjectIter = ObjectContainer::Iterator;
/**
* An abstract base class for constrainers.
/**
* Virtual destructor.
*/
- virtual ~Constrainer();
+ ~Constrainer() override;
public: // Object::Observer methods
/**
* @copydoc Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object ){}
+ void SceneObjectAdded( Object& object ) override{}
/**
* @copydoc Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object ){}
+ void SceneObjectRemoved( Object& object ) override{}
/**
* @copydoc Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
public:
ConstraintBase::ConstraintBase( Object& object, Property::Index targetPropertyIndex, SourceContainer& sources )
: mEventThreadServices( EventThreadServices::Get() ),
mTargetObject( &object ),
- mSceneGraphConstraint( NULL ),
+ mSceneGraphConstraint( nullptr ),
mSources( sources ),
mObservedObjects(),
mTargetPropertyIndex( targetPropertyIndex ),
// Observe the object providing this property
if ( OBJECT_PROPERTY == source.sourceType )
{
- if ( source.object != NULL )
+ if ( source.object != nullptr )
{
ObserveObject( *source.object );
}
// Remove from scene-graph
RemoveConstraintMessage( GetEventThreadServices(), propertyOwner, *(mSceneGraphConstraint) );
// mSceneGraphConstraint will be deleted in update-thread, remove dangling pointer
- mSceneGraphConstraint = NULL;
+ mSceneGraphConstraint = nullptr;
}
}
}
void ConstraintBase::SceneObjectAdded( Object& object )
{
if ( mApplied &&
- ( NULL == mSceneGraphConstraint ) &&
+ ( nullptr == mSceneGraphConstraint ) &&
mTargetObject )
{
ConnectConstraint();
}
// mSceneGraphConstraint will be deleted in update-thread, remove dangling pointer
- mSceneGraphConstraint = NULL;
+ mSceneGraphConstraint = nullptr;
}
}
mSources.clear();
// Discard all object & scene-graph pointers
- mSceneGraphConstraint = NULL;
- mTargetObject = NULL;
+ mSceneGraphConstraint = nullptr;
+ mTargetObject = nullptr;
}
void ConstraintBase::ObserveObject( Object& object )
class EventThreadServices;
class Object;
-typedef Dali::Vector<Object*> ObjectContainer;
-typedef ObjectContainer::Iterator ObjectIter;
+using ObjectContainer = Dali::Vector<Object*>;
+using ObjectIter = ObjectContainer::Iterator;
namespace SceneGraph
{
class ConstraintBase : public BaseObject, public Object::Observer
{
public:
-
- typedef Dali::Constraint::RemoveAction RemoveAction;
+ using RemoveAction = Dali::Constraint::RemoveAction;
/**
* Constructor.
/**
* Virtual destructor.
*/
- virtual ~ConstraintBase();
+ ~ConstraintBase() override;
/**
* Adds a constraint source to the constraint
/**
* @copydoc Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object );
+ void SceneObjectAdded( Object& object ) override;
/**
* @copydoc Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object );
+ void SceneObjectRemoved( Object& object ) override;
/**
* @copydoc Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
// This is not responsible for removing constraints.
}
/**
* @copydoc ConstraintBase::DoClone()
*/
- ConstraintBase* DoClone( Object& object ) override final
+ ConstraintBase* DoClone( Object& object ) final
{
ConstraintFunctionPtr funcPtr( mUserFunction->Clone() );
return new Constraint( object,
/**
* @copydoc ConstraintBase::ConnectConstraint()
*/
- void ConnectConstraint() override final
+ void ConnectConstraint() final
{
// Should not come here if target object has been destroyed
DALI_ASSERT_DEBUG( nullptr != mTargetObject );
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
// This is not responsible for removing constraints.
}
/**
* @copydoc ConstraintBase::DoClone()
*/
- virtual ConstraintBase* DoClone( Object& object ) override final
+ ConstraintBase* DoClone( Object& object ) final
{
ConstraintFunctionPtr funcPtr( mUserFunction->Clone() );
return new Constraint( object,
/**
* @copydoc ConstraintBase::ConnectConstraint()
*/
- void ConnectConstraint() override final
+ void ConnectConstraint() final
{
// Should not come here if target object has been destroyed
DALI_ASSERT_DEBUG( nullptr != mTargetObject );
{
struct Source;
-typedef std::vector<Source> SourceContainer;
-typedef SourceContainer::iterator SourceIter;
+using SourceContainer = std::vector<Source>;
+using SourceIter = SourceContainer::iterator;
/**
* The source of an input property for a constraint.
Source()
: sourceType( OBJECT_PROPERTY ),
propertyIndex( Property::INVALID_INDEX ),
- object( NULL )
+ object( nullptr )
{
}
Source( Dali::ConstraintSource& source )
: sourceType( source.sourceType ),
propertyIndex( source.propertyIndex ),
- object( NULL )
+ object( nullptr )
{
if ( source.object )
{
class KeyFrameChannel : public KeyFrameChannelBase
{
public:
- typedef std::vector<ProgressValue<V> > ProgressValues;
+ using ProgressValues = std::vector<ProgressValue<V> >;
KeyFrameChannel(KeyFrameChannelId channel_id, ProgressValues& values )
: KeyFrameChannelBase(channel_id),
}
- virtual ~KeyFrameChannel()
+ ~KeyFrameChannel() override
{
}
- bool IsActive (float progress);
+ bool IsActive (float progress) override;
V GetValue(float progress, Dali::Animation::Interpolation interpolation) const;
return interpolatedV;
}
-typedef KeyFrameChannel<float> KeyFrameChannelNumber;
-typedef KeyFrameChannel<Vector2> KeyFrameChannelVector2;
-typedef KeyFrameChannel<Vector3> KeyFrameChannelVector3;
-typedef KeyFrameChannel<Vector4> KeyFrameChannelVector4;
-typedef KeyFrameChannel<Quaternion> KeyFrameChannelQuaternion;
-typedef KeyFrameChannel<AngleAxis> KeyFrameChannelAngleAxis;
-
+using KeyFrameChannelNumber = KeyFrameChannel<float>;
+using KeyFrameChannelVector2 = KeyFrameChannel<Vector2>;
+using KeyFrameChannelVector3 = KeyFrameChannel<Vector3>;
+using KeyFrameChannelVector4 = KeyFrameChannel<Vector4>;
+using KeyFrameChannelQuaternion = KeyFrameChannel<Quaternion>;
+using KeyFrameChannelAngleAxis = KeyFrameChannel<AngleAxis>;
} // Internal
} // namespace Dali
KeyFrames::KeyFrames()
: mType(Property::NONE),
- mKeyFrames(NULL)
+ mKeyFrames(nullptr)
{
}
{
class KeyFrameSpec;
class KeyFrames;
-typedef IntrusivePtr<KeyFrames> KeyFramesPtr;
-
+using KeyFramesPtr = IntrusivePtr<KeyFrames>;
/**
* KeyFrames class is responsible for creating and building a specialized KeyFrame class
KeyFrames();
protected:
- virtual ~KeyFrames();
+ ~KeyFrames() override;
private:
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~KeyFrameSpec() {}
+ ~KeyFrameSpec() override {}
};
class KeyFrameBaseSpec : public KeyFrameSpec
{
private:
- typedef ProgressValue<V> PV;
- typedef std::vector<PV> PVContainer;
+ using PV = ProgressValue<V>;
+ using PVContainer = std::vector<PV>;
PVContainer mPVs; // The ProgressValue pairs
KeyFrameChannel<V>* mKeyFrames; // The key frame interpolator
/**
* Destructor. Ensure progress value pairs are cleared down
*/
- virtual ~KeyFrameBaseSpec<V>()
+ ~KeyFrameBaseSpec<V>() override
{
delete mKeyFrames;
mPVs.clear();
* Get the number of key frames
* @return The size of the progress value vector
*/
- virtual std::size_t GetNumberOfKeyFrames() const
+ std::size_t GetNumberOfKeyFrames() const override
{
return mPVs.size();
}
/**
* @copydoc KeyFrameSpec::GetKeyFrameAsValue()
*/
- virtual void GetKeyFrameAsValue( std::size_t index, Property::Value& value )
+ void GetKeyFrameAsValue( std::size_t index, Property::Value& value ) override
{
value = mPVs[index].mValue;
}
}
};
-typedef KeyFrameBaseSpec<float> KeyFrameNumber;
-typedef KeyFrameBaseSpec<bool> KeyFrameBoolean;
-typedef KeyFrameBaseSpec<int> KeyFrameInteger;
-typedef KeyFrameBaseSpec<Vector2> KeyFrameVector2;
-typedef KeyFrameBaseSpec<Vector3> KeyFrameVector3;
-typedef KeyFrameBaseSpec<Vector4> KeyFrameVector4;
-typedef KeyFrameBaseSpec<Quaternion> KeyFrameQuaternion;
-
-typedef IntrusivePtr<KeyFrameBoolean> KeyFrameBooleanPtr;
-typedef IntrusivePtr<KeyFrameNumber> KeyFrameNumberPtr;
-typedef IntrusivePtr<KeyFrameInteger> KeyFrameIntegerPtr;
-typedef IntrusivePtr<KeyFrameVector2> KeyFrameVector2Ptr;
-typedef IntrusivePtr<KeyFrameVector3> KeyFrameVector3Ptr;
-typedef IntrusivePtr<KeyFrameVector4> KeyFrameVector4Ptr;
-typedef IntrusivePtr<KeyFrameQuaternion> KeyFrameQuaternionPtr;
-
+using KeyFrameNumber = KeyFrameBaseSpec<float>;
+using KeyFrameBoolean = KeyFrameBaseSpec<bool>;
+using KeyFrameInteger = KeyFrameBaseSpec<int>;
+using KeyFrameVector2 = KeyFrameBaseSpec<Vector2>;
+using KeyFrameVector3 = KeyFrameBaseSpec<Vector3>;
+using KeyFrameVector4 = KeyFrameBaseSpec<Vector4>;
+using KeyFrameQuaternion = KeyFrameBaseSpec<Quaternion>;
+
+using KeyFrameBooleanPtr = IntrusivePtr<KeyFrameBoolean>;
+using KeyFrameNumberPtr = IntrusivePtr<KeyFrameNumber>;
+using KeyFrameIntegerPtr = IntrusivePtr<KeyFrameInteger>;
+using KeyFrameVector2Ptr = IntrusivePtr<KeyFrameVector2>;
+using KeyFrameVector3Ptr = IntrusivePtr<KeyFrameVector3>;
+using KeyFrameVector4Ptr = IntrusivePtr<KeyFrameVector4>;
+using KeyFrameQuaternionPtr = IntrusivePtr<KeyFrameQuaternion>;
inline void GetSpecialization(Internal::KeyFrames& keyFrames, Internal::KeyFrameBoolean*& keyFrameSpec)
{
/**
* virtual destructor
*/
- virtual ~LinearConstrainer();
+ ~LinearConstrainer() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
public:
/**
* @copydoc Dali::PathConstrainer::Apply
*/
- void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap );
+ void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap ) override;
private:
/**
* virtual destructor
*/
- virtual ~PathConstrainer();
+ ~PathConstrainer() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
public:
/**
* @copydoc Dali::PathConstrainer::Apply
*/
- void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap );
+ void Apply( Property target, Property source, const Vector2& range, const Vector2& wrap ) override;
private:
namespace Internal
{
-typedef IntrusivePtr<Path> PathPtr;
+using PathPtr = IntrusivePtr<Path>;
/**
* A 3D path
/**
* virtual destructor
*/
- virtual ~Path();
+ ~Path() override;
private:
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
public:
template <class P>
struct PropertyConstraintPtr
{
- typedef OwnerPointer< PropertyConstraint<P> > Type;
+ using Type = OwnerPointer<PropertyConstraint<P> >;
};
} // namespace Internal
/**
* Virtual Destructor
*/
- virtual ~PropertyInputIndexer()
+ ~PropertyInputIndexer() override
{
}
/**
* @copydoc Dali::Internal::PropertyInput::GetType()
*/
- virtual Property::Type GetType() const
+ Property::Type GetType() const override
{
return mInput->GetType();
}
/**
* @copydoc Dali::Internal::PropertyInput::GetBoolean()
*/
- virtual const bool& GetBoolean() const
+ const bool& GetBoolean() const override
{
return mInput->GetConstraintInputBoolean( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetInteger()
*/
- virtual const int& GetInteger() const
+ const int& GetInteger() const override
{
return mInput->GetConstraintInputInteger( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetFloat()
*/
- virtual const float& GetFloat() const
+ const float& GetFloat() const override
{
return mInput->GetConstraintInputFloat( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2() const
+ const Vector2& GetVector2() const override
{
return mInput->GetConstraintInputVector2( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3() const
+ const Vector3& GetVector3() const override
{
return mInput->GetConstraintInputVector3( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4() const
+ const Vector4& GetVector4() const override
{
return mInput->GetConstraintInputVector4( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetMatrix3()
*/
- virtual const Matrix3& GetMatrix3() const
+ const Matrix3& GetMatrix3() const override
{
return mInput->GetConstraintInputMatrix3( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::GetMatrix()
*/
- virtual const Matrix& GetMatrix() const
+ const Matrix& GetMatrix() const override
{
return mInput->GetConstraintInputMatrix( mBufferIndex );
}
/**
* @copydoc Dali::Internal::PropertyInput::Quaternion()
*/
- virtual const Quaternion& GetQuaternion() const
+ const Quaternion& GetQuaternion() const override
{
return mInput->GetConstraintInputQuaternion( mBufferIndex );
}
}
}
-typedef Dali::Mutex MessageQueueMutex;
-typedef OwnerContainer< MessageBase* > MessageContainer;
+using MessageQueueMutex = Dali::Mutex;
+using MessageContainer = OwnerContainer<MessageBase*>;
struct NotificationManager::Impl
{
class ObjectConnector
{
public:
- typedef IntrusivePtr<Object> ObjectPtr;
+ using ObjectPtr = IntrusivePtr<Object>;
/**
* @brief Default constructor.
return Property::NONE;
}
-void Object::SetProperty( Property::Index index, const Property::Value& propertyValue )
+void Object::SetProperty(Property::Index index, Property::Value propertyValue)
{
DALI_ASSERT_ALWAYS(index > Property::INVALID_INDEX && "Property index is out of bounds" );
if ( propertySet )
{
OnPropertySet( index, propertyValue );
- Dali::Handle handle( this );
- mPropertySetSignal.Emit( handle, index, propertyValue );
+ if(!mPropertySetSignal.Empty())
+ {
+ Dali::Handle handle(this);
+ mPropertySetSignal.Emit(handle, index, propertyValue);
+ }
}
}
}
}
-Property::Index Object::RegisterProperty( const std::string& name, const Property::Value& propertyValue )
+Property::Index Object::RegisterProperty(std::string name, Property::Value propertyValue)
{
- return RegisterProperty( name, Property::INVALID_KEY, propertyValue, Property::ANIMATABLE );
+ return RegisterProperty(std::move(name), Property::INVALID_KEY, std::move(propertyValue), Property::ANIMATABLE);
}
-Property::Index Object::RegisterProperty( const std::string& name, Property::Index key, const Property::Value& propertyValue )
+Property::Index Object::RegisterProperty(std::string name, Property::Index key, Property::Value propertyValue)
{
- return RegisterProperty( name, key, propertyValue, Property::ANIMATABLE );
+ return RegisterProperty(std::move(name), key, std::move(propertyValue), Property::ANIMATABLE);
}
void Object::SetProperties( const Property::Map& properties )
}
}
-Property::Index Object::RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode )
+Property::Index Object::RegisterProperty(std::string name,
+ Property::Value propertyValue,
+ Property::AccessMode accessMode)
{
- return RegisterProperty( name, Property::INVALID_KEY, propertyValue, accessMode );
+ return RegisterProperty(std::move(name), Property::INVALID_KEY, std::move(propertyValue), accessMode);
}
-Property::Index Object::RegisterProperty( const std::string& name, Property::Index key, const Property::Value& propertyValue, Property::AccessMode accessMode )
+Property::Index Object::RegisterProperty(std::string name,
+ Property::Index key,
+ Property::Value propertyValue,
+ Property::AccessMode accessMode)
{
// If property with the required key already exists, then just set it.
Property::Index index = Property::INVALID_INDEX;
if( index != Property::INVALID_INDEX ) // If there was a valid index found by either key, set it.
{
- SetProperty( index, propertyValue );
+ SetProperty(index, std::move(propertyValue));
}
else
{
// Otherwise register the property
if( Property::ANIMATABLE == accessMode )
{
- index = RegisterSceneGraphProperty( name, key, PROPERTY_CUSTOM_START_INDEX + static_cast<Property::Index>( mCustomProperties.Count() ), propertyValue );
- AddUniformMapping( index, name );
+ index = RegisterSceneGraphProperty(
+ name,
+ key,
+ PROPERTY_CUSTOM_START_INDEX + static_cast<Property::Index>(mCustomProperties.Count()),
+ std::move(propertyValue));
+ AddUniformMapping(index, std::move(name));
}
else
{
// Add entry to the property lookup
index = PROPERTY_CUSTOM_START_INDEX + static_cast<Property::Index>( mCustomProperties.Count() );
- CustomPropertyMetadata* customProperty = new CustomPropertyMetadata( name, propertyValue, accessMode );
+ CustomPropertyMetadata* customProperty =
+ new CustomPropertyMetadata(name, std::move(propertyValue), accessMode);
// Resolve index for the child property
Object* parent = GetParentObject();
}
}
-void Object::AddUniformMapping( Property::Index propertyIndex, const std::string& uniformName ) const
+void Object::AddUniformMapping(Property::Index propertyIndex, std::string uniformName) const
{
// Get the address of the property if it's a scene property
const PropertyInputImpl* propertyPtr = GetSceneObjectInputProperty( propertyIndex );
{
const SceneGraph::PropertyOwner& sceneObject = GetSceneObject();
- OwnerPointer< SceneGraph::UniformPropertyMapping > map = new SceneGraph::UniformPropertyMapping( uniformName, propertyPtr );
+ OwnerPointer<SceneGraph::UniformPropertyMapping> map =
+ new SceneGraph::UniformPropertyMapping(std::move(uniformName), propertyPtr);
// Message takes ownership of Uniform map (and will delete it after copy)
AddUniformMapMessage( const_cast<EventThreadServices&>(GetEventThreadServices()), sceneObject, map );
}
/**
* @copydoc Dali::Handle::SetProperty()
*/
- void SetProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetProperty(Property::Index index, Property::Value propertyValue);
/**
* @copydoc Dali::Handle::GetProperty()
/**
* @copydoc Dali::Handle::RegisterProperty()
*/
- Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue );
+ Property::Index RegisterProperty(std::string name, Property::Value propertyValue);
/**
* @copydoc Dali::Handle::RegisterProperty()
*/
- Property::Index RegisterProperty( const std::string& name, Property::Index key, const Property::Value& propertyValue );
+ Property::Index RegisterProperty(std::string name, Property::Index key, Property::Value propertyValue);
/**
* @copydoc Dali::DevelHandle::SetProperties()
/**
* @copydoc Dali::Handle::RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode)
*/
- Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode );
+ Property::Index RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode);
/**
* @brief Implementing method for this override
*/
- Property::Index RegisterProperty( const std::string& name, Property::Index key, const Property::Value& propertyValue, Property::AccessMode accessMode );
+ Property::Index RegisterProperty(std::string name,
+ Property::Index key,
+ Property::Value propertyValue,
+ Property::AccessMode accessMode);
/**
* @brief returns true if the custom property exists on this object.
* @param propertyIndex index of the property
* @param uniformName name of the uniform (same as property name)
*/
- void AddUniformMapping( Property::Index propertyIndex, const std::string& uniformName ) const;
+ void AddUniformMapping(Property::Index propertyIndex, std::string uniformName) const;
/**
* Removes uniform mapping for given property
virtual int32_t GetPropertyComponentIndex( Property::Index index ) const;
/**
+ * Query whether playing an animation is possible or not.
+ * @return true if playing an animation is possible.
+ */
+ virtual bool IsAnimationPossible() const
+ {
+ return true;
+ }
+
+ /**
* @copydoc Dali::Handle::PropertySetSignal()
*/
Handle::PropertySetSignalType& PropertySetSignal();
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Object();
+ ~Object() override;
/**
* Called immediately by derived classes, after the scene-object has been created & passed to the scene-graph.
const char* const SIGNAL_OBJECT_CREATED = "objectCreated";
const char* const SIGNAL_OBJECT_DESTROYED = "objectDestroyed";
-TypeRegistration mType( typeid( Dali::ObjectRegistry ), typeid( Dali::BaseHandle ), NULL );
+TypeRegistration mType( typeid( Dali::ObjectRegistry ), typeid( Dali::BaseHandle ), nullptr );
SignalConnectorType signalConnector1( mType, SIGNAL_OBJECT_CREATED, &ObjectRegistry::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_OBJECT_DESTROYED, &ObjectRegistry::DoConnectSignal );
class ObjectRegistry;
-typedef IntrusivePtr<ObjectRegistry> ObjectRegistryPtr;
+using ObjectRegistryPtr = IntrusivePtr<ObjectRegistry>;
/**
* The ObjectRegistry notifies it's observers when an object is created.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- ~ObjectRegistry();
+ ~ObjectRegistry() override;
private:
bool XyPlaneIntersect( const Vector4& pointA, const Vector4& pointB, Vector4& intersect )
{
- const Vector4* near = NULL;
- const Vector4* far = NULL;
+ const Vector4* near = nullptr;
+ const Vector4* far = nullptr;
if ( pointA.z > 0.0f && pointB.z < 0.0f )
{
/**
* Virtual destructor
*/
- virtual ~PropertyCondition();
+ ~PropertyCondition() override;
private:
/**
* These macros are used to define a table of property details per object.
- * The index property is only compiled in for DEBUG_ENABLED builds and allows checking the table index VS the property enum index.
- * DALI_PROPERTY_TABLE_END Forces a run-time check that will happen once.
+ * Checking of the table index VS the property enum index happens during compile time.
* the macros define an instance of PropertyMetadata with the name that is passed to DALI_PROPERTY_TABLE_END
*/
-#define DALI_PROPERTY_TABLE_BEGIN const Dali::PropertyDetails DEFAULT_PROPERTY_DETAILS[] = {
-#ifdef DEBUG_ENABLED
-#define DALI_PROPERTY_TABLE_END( startIndex, constantName ) }; const Property::Index DEFAULT_PROPERTY_COUNT = static_cast<Property::Index>( sizeof( DEFAULT_PROPERTY_DETAILS ) / sizeof( Dali::PropertyDetails ) ); \
- struct PROPERTY_CHECK \
- { \
- PROPERTY_CHECK() \
- { \
- for( int i = 0; i < DEFAULT_PROPERTY_COUNT; i++ ) \
- { \
- if ( DEFAULT_PROPERTY_DETAILS[i].enumIndex != ( startIndex + i ) ) \
- { \
- DALI_LOG_ERROR( "Checking property failed: index:%d, enumIndex:%d == index+start:%d, (name:%s)\n", i, \
- DEFAULT_PROPERTY_DETAILS[i].enumIndex, (startIndex + i), DEFAULT_PROPERTY_DETAILS[i].name ); \
- DALI_ASSERT_DEBUG( false && "Property enumeration mismatch" ); \
- } \
- } \
- } \
- }; \
- constexpr Dali::DefaultPropertyMetadata constantName{ DEFAULT_PROPERTY_DETAILS, DEFAULT_PROPERTY_COUNT }; \
- static PROPERTY_CHECK PROPERTY_CHECK_INSTANCE;
-#else
-#define DALI_PROPERTY_TABLE_END( startIndex, constantName ) }; const Property::Index DEFAULT_PROPERTY_COUNT = static_cast<Property::Index>( sizeof( DEFAULT_PROPERTY_DETAILS ) / sizeof( Dali::PropertyDetails ) );\
- constexpr Dali::DefaultPropertyMetadata constantName{ DEFAULT_PROPERTY_DETAILS, DEFAULT_PROPERTY_COUNT };
-#endif
+#define DALI_PROPERTY_TABLE_BEGIN static constexpr Dali::PropertyDetails DEFAULT_PROPERTY_DETAILS[] = {
+
+#define DALI_PROPERTY_TABLE_END(startIndex, tableName) \
+ }; \
+ static constexpr auto tableName = GeneratePropertyMetadata(DEFAULT_PROPERTY_DETAILS); \
+ static_assert(CheckPropertyMetadata(tableName, startIndex), "Property enumeration mismatch");
+
#define DALI_PROPERTY( text, type, writable, animatable, constraint, index ) { text, index, Dali::Property::type, writable, animatable, constraint },
/**
*/
bool IsAnimatable( void ) const
{
- return NULL != mSceneGraphProperty;
+ return nullptr != mSceneGraphProperty;
}
/**
/**
* @brief Destructor.
*/
- virtual ~AnimatablePropertyMetadata()
+ ~AnimatablePropertyMetadata() override
{
}
CustomPropertyMetadata( const std::string& propertyName,
const Property::Value& propertyValue,
Property::AccessMode accessMode )
- : PropertyMetadata( propertyValue, NULL, ( accessMode != Property::READ_ONLY ) ),
+ : PropertyMetadata( propertyValue, nullptr, ( accessMode != Property::READ_ONLY ) ),
name( propertyName ),
key( Property::INVALID_KEY ),
childPropertyIndex( Property::INVALID_INDEX )
/**
* @brief Destructor.
*/
- virtual ~CustomPropertyMetadata()
+ ~CustomPropertyMetadata() override
{
}
int componentIndex,
const Dali::PropertyCondition& condition )
: mUpdateManager( updateManager ),
- mPropertyNotification( NULL ),
+ mPropertyNotification( nullptr ),
mPropertyNotificationManager( propertyNotificationManager ),
mObjectPropertyIndex( target.propertyIndex ),
mPropertyType( Property::NONE ),
void PropertyNotification::DestroySceneObject()
{
- if ( mPropertyNotification != NULL )
+ if ( mPropertyNotification != nullptr )
{
// Remove PropertyNotification using a message to the update manager
RemovePropertyNotificationMessage( mUpdateManager, *mPropertyNotification );
- mPropertyNotification = NULL;
+ mPropertyNotification = nullptr;
}
}
class Object;
class PropertyNotificationManager;
-typedef IntrusivePtr<PropertyNotification> PropertyNotificationPtr;
+using PropertyNotificationPtr = IntrusivePtr<PropertyNotification>;
/**
* PropertyNotification is a proxy for a SceneGraph::PropertyNotification object.
class PropertyNotification : public BaseObject
{
public:
-
- typedef Dali::PropertyNotification::NotifyMode NotifyMode;
- typedef PropertyCondition::Type ConditionType;
+ using NotifyMode = Dali::PropertyNotification::NotifyMode;
+ using ConditionType = PropertyCondition::Type;
/**
* RawArgumentContainer provides fast direct access to arguments for condition evaluation.
*/
- typedef Dali::Vector<float> RawArgumentContainer;
+ using RawArgumentContainer = Dali::Vector<float>;
/**
* Create a new PropertyNotification object.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PropertyNotification();
+ ~PropertyNotification() override;
private:
/**
* Virtual destructor.
*/
- virtual ~PropertyNotificationManager();
+ ~PropertyNotificationManager() override;
/**
* Called when a PropertyNotification is constructed.
/**
* @copydoc PropertyNotifier::NotifyProperty
*/
- virtual void NotifyProperty( SceneGraph::PropertyNotification* propertyNotification, bool validity );
+ void NotifyProperty( SceneGraph::PropertyNotification* propertyNotification, bool validity ) override;
private:
/**
* virtual destructor
*/
- virtual ~Scene();
+ ~Scene() override;
/**
* @copydoc Dali::Integration::Scene::Add
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() override;
private:
class Stage;
-typedef Stage* StagePtr;
+using StagePtr = Stage *;
} // Internal
const char* const SIGNAL_CONTEXT_REGAINED = "contextRegained";
const char* const SIGNAL_SCENE_CREATED = "sceneCreated";
-TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), NULL );
+TypeRegistration mType( typeid(Dali::Stage), typeid(Dali::BaseHandle), nullptr );
SignalConnectorType signalConnector1( mType, SIGNAL_KEY_EVENT, &Stage::DoConnectSignal );
SignalConnectorType signalConnector2( mType, SIGNAL_EVENT_PROCESSING_FINISHED, &Stage::DoConnectSignal );
StagePtr Stage::GetCurrent()
{
- StagePtr stage( NULL );
+ StagePtr stage( nullptr );
// no checking in this version
ThreadLocalStorage* tls = ThreadLocalStorage::GetInternal();
if( tls )
* From RenderTaskDefaults; retrieve the default root actor.
* @return The default root actor.
*/
- virtual Actor& GetDefaultRootActor();
+ Actor& GetDefaultRootActor() override;
/**
* From RenderTaskDefaults; retrieve the default camera actor.
* @return The default camera actor.
*/
- virtual CameraActor& GetDefaultCameraActor();
+ CameraActor& GetDefaultCameraActor() override;
// Layers
/**
* @copydoc Dali::Integration::NotifyContextLost();
*/
- virtual void NotifyContextLost();
+ void NotifyContextLost() override;
/**
* @copydoc Dali::Integration::NotifyContextRegained();
*/
- virtual void NotifyContextRegained();
+ void NotifyContextRegained() override;
private:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Stage();
+ ~Stage() override;
private:
/**
* Virtual Destructor
*/
- virtual ~ThreadLocalStorage();
+ ~ThreadLocalStorage() override;
// Undefined
ThreadLocalStorage( const ThreadLocalStorage& );
// using the address of the type name string as compiler will allocate these once per library
// and we don't support un/re-loading of dali libraries while singleton service is alive
- typedef std::pair< const char*, BaseHandle> SingletonPair;
- typedef std::vector< SingletonPair > SingletonContainer;
- typedef SingletonContainer::const_iterator SingletonConstIter;
+ using SingletonPair = std::pair<const char*, BaseHandle>;
+ using SingletonContainer = std::vector<SingletonPair>;
+ using SingletonConstIter = SingletonContainer::const_iterator;
SingletonContainer mSingletonContainer; ///< The container to look up singleton by its type name
// default or custom
if ( mDefaultProperties && ( index < DEFAULT_PROPERTY_MAX_COUNT ) )
{
- const char* name = nullptr;
+ std::string_view name;
if( GetDefaultPropertyField( mDefaultProperties, mDefaultPropertyCount,index, &Dali::PropertyDetails::name, name ) )
{
propertyName = name;
return propertyName;
}
-void TypeInfo::AddActionFunction( const std::string &actionName, Dali::TypeInfo::ActionFunction function )
+void TypeInfo::AddActionFunction(std::string actionName, Dali::TypeInfo::ActionFunction function)
{
- if( NULL == function)
+ if( nullptr == function)
{
DALI_LOG_WARNING("Action function is empty\n");
}
if( iter == mActions.end() )
{
- mActions.push_back( ActionPair( actionName, function ) );
+ mActions.push_back(ActionPair(std::move(actionName), function));
}
else
{
}
}
-void TypeInfo::AddConnectorFunction( const std::string& signalName, Dali::TypeInfo::SignalConnectorFunction function )
+void TypeInfo::AddConnectorFunction(std::string signalName, Dali::TypeInfo::SignalConnectorFunction function)
{
- if( NULL == function)
+ if( nullptr == function)
{
DALI_LOG_WARNING("Connector function is empty\n");
}
if( iter == mSignalConnectors.end() )
{
- mSignalConnectors.push_back( ConnectionPair( signalName, function ) );
+ mSignalConnectors.push_back(ConnectionPair(std::move(signalName), function));
}
else
{
}
}
-void TypeInfo::AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc )
+void TypeInfo::AddProperty(std::string name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc)
{
// The setter can be empty as a property can be read-only.
- if ( NULL == getFunc )
+ if ( nullptr == getFunc )
{
DALI_ASSERT_ALWAYS( ! "GetProperty Function is empty" );
}
if ( iter == mRegisteredProperties.end() )
{
- mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, setFunc, getFunc, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
+ mRegisteredProperties.push_back(RegisteredPropertyPair(index, RegisteredProperty(type, setFunc, getFunc, std::move(name), Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX)));
}
else
{
}
}
-void TypeInfo::AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc)
+void TypeInfo::AddProperty(std::string name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc)
{
// The setter can be empty as a property can be read-only.
- if ( NULL == getFunc )
+ if ( nullptr == getFunc )
{
DALI_ASSERT_ALWAYS( ! "GetProperty Function is empty" );
}
if ( iter == mRegisteredProperties.end() )
{
- mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, setFunc, getFunc, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
+ mRegisteredProperties.push_back(RegisteredPropertyPair(index, RegisteredProperty(type, setFunc, getFunc, std::move(name), Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX)));
}
else
{
}
-
-void TypeInfo::AddAnimatableProperty( const std::string& name, Property::Index index, Property::Type type )
+void TypeInfo::AddAnimatableProperty(std::string name, Property::Index index, Property::Type type)
{
RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
PairFinder< Property::Index, RegisteredPropertyPair>(index) );
if ( iter == mRegisteredProperties.end() )
{
- mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
+ mRegisteredProperties.push_back(RegisteredPropertyPair(index, RegisteredProperty(type, std::move(name), Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX)));
}
else
{
}
}
-void TypeInfo::AddAnimatableProperty( const std::string& name, Property::Index index, const Property::Value& defaultValue )
+void TypeInfo::AddAnimatableProperty(std::string name, Property::Index index, Property::Value defaultValue)
{
RegisteredPropertyContainer::iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
PairFinder< Property::Index, RegisteredPropertyPair>(index) );
if ( iter == mRegisteredProperties.end() )
{
- mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( defaultValue.GetType(), name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
- mPropertyDefaultValues.push_back( PropertyDefaultValuePair( index, defaultValue ) );
+ mRegisteredProperties.push_back(RegisteredPropertyPair(index, RegisteredProperty(defaultValue.GetType(), std::move(name), Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX)));
+ mPropertyDefaultValues.push_back(PropertyDefaultValuePair(index, std::move(defaultValue)));
}
else
{
}
}
-void TypeInfo::AddAnimatablePropertyComponent( const std::string& name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex )
+void TypeInfo::AddAnimatablePropertyComponent(std::string name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex)
{
Property::Type type = GetPropertyType( baseIndex );
DALI_ASSERT_ALWAYS( ( type == Property::VECTOR2 || type == Property::VECTOR3 || type == Property::VECTOR4 ) && "Base property does not support component" );
if ( iter == mRegisteredProperties.end() )
{
- mRegisteredProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, name, baseIndex, componentIndex ) ) );
+ mRegisteredProperties.push_back(RegisteredPropertyPair(index, RegisteredProperty(type, std::move(name), baseIndex, componentIndex)));
success = true;
}
}
DALI_ASSERT_ALWAYS( success && "Property component already registered" );
}
-void TypeInfo::AddChildProperty( const std::string& name, Property::Index index, Property::Type type )
+void TypeInfo::AddChildProperty(std::string name, Property::Index index, Property::Type type)
{
RegisteredPropertyContainer::iterator iter = find_if( mRegisteredChildProperties.begin(), mRegisteredChildProperties.end(),
PairFinder< Property::Index, RegisteredPropertyPair>(index) );
if ( iter == mRegisteredChildProperties.end() )
{
- mRegisteredChildProperties.push_back( RegisteredPropertyPair( index, RegisteredProperty( type, name, Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX ) ) );
+ mRegisteredChildProperties.push_back(RegisteredPropertyPair(index, RegisteredProperty(type, std::move(name), Property::INVALID_INDEX, Property::INVALID_COMPONENT_INDEX)));
}
else
{
{
for( Property::Index tableIndex = 0; tableIndex < mDefaultPropertyCount; ++tableIndex )
{
- if( 0 == name.compare( mDefaultProperties[ tableIndex ].name ) )
+ if(mDefaultProperties[tableIndex].name == name)
{
index = mDefaultProperties[ tableIndex ].enumIndex;
found = true;
return Property::Value(); // return none
}
-void TypeInfo::SetProperty( BaseObject *object, Property::Index index, const Property::Value& value ) const
+void TypeInfo::SetProperty(BaseObject* object, Property::Index index, Property::Value value) const
{
RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
PairFinder< Property::Index, RegisteredPropertyPair >( index ) );
}
else
{
- iter->second.setFunc( object, index, value );
+ iter->second.setFunc(object, index, std::move(value));
}
}
}
else if( GetBaseType( mBaseType, mTypeRegistry, mBaseTypeName ) )
{
// call base type recursively
- mBaseType->SetProperty( object, index, value );
+ mBaseType->SetProperty(object, index, std::move(value));
}
else
{
}
}
-void TypeInfo::SetProperty( BaseObject *object, const std::string& name, const Property::Value& value ) const
+void TypeInfo::SetProperty(BaseObject* object, const std::string& name, Property::Value value) const
{
RegisteredPropertyContainer::const_iterator iter = find_if( mRegisteredProperties.begin(), mRegisteredProperties.end(),
PropertyNameFinder< RegisteredPropertyPair >( name ) );
}
else
{
- iter->second.setFunc( object, iter->first, value );
+ iter->second.setFunc(object, iter->first, std::move(value));
}
}
else if( GetBaseType( mBaseType, mTypeRegistry, mBaseTypeName ) )
{
// call base type recursively
- mBaseType->SetProperty( object, name, value );
+ mBaseType->SetProperty(object, name, std::move(value));
}
else
{
/**
* Destructor
*/
- virtual ~TypeInfo();
+ ~TypeInfo() override;
/**
* @copydoc Dali::TypeInfo::GetName
/*
* Add an action function
*/
- void AddActionFunction( const std::string &actionName, Dali::TypeInfo::ActionFunction function );
+ void AddActionFunction(std::string actionName, Dali::TypeInfo::ActionFunction function);
/*
* Add a function for connecting a signal.
* @param[in] signalName The name of the signal.
* @param[in] function The function used for connecting to the signal.
*/
- void AddConnectorFunction( const std::string& signalName, Dali::TypeInfo::SignalConnectorFunction function );
+ void AddConnectorFunction(std::string signalName, Dali::TypeInfo::SignalConnectorFunction function);
/**
* Adds an event-thread only property to the type.
* @param[in] setFunc The function to call to set the property (Can be nullptr).
* @param[in] getFunc The function to call to retrieve the value of the property.
*/
- void AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc );
+ void AddProperty(std::string name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc);
/**
* Adds an event-thread only property to the type.
* @param[in] setFunc The function to call to set the property (Can be nullptr).
* @param[in] getFunc The function to call to retrieve the value of the property.
*/
- void AddProperty( const std::string& name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc);
+ void AddProperty(std::string name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc);
/**
* Adds an animatable property to the type.
* @param[in] index The index of the property
* @param[in] type The Property::Type.
*/
- void AddAnimatableProperty( const std::string& name, Property::Index index, Property::Type type );
+ void AddAnimatableProperty(std::string name, Property::Index index, Property::Type type);
/**
* Adds an animatable property with the given default value.
* @param[in] index The index of the property
* @param[in] type The Property::Type.
*/
- void AddAnimatableProperty( const std::string& name, Property::Index index, const Property::Value& defaultValue );
+ void AddAnimatableProperty(std::string name, Property::Index index, Property::Value defaultValue);
/**
* Adds a component of an animatable property to the type.
* @param[in] baseIndex The index of the base animatable property
* @param[in] component The index The index of the component.
*/
- void AddAnimatablePropertyComponent( const std::string& name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex );
+ void AddAnimatablePropertyComponent(std::string name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex);
/**
* Adds a child property to the type.
* @param[in] index The index of the property
* @param[in] type The Property::Type.
*/
- void AddChildProperty( const std::string& name, Property::Index index, Property::Type type );
+ void AddChildProperty(std::string name, Property::Index index, Property::Type type);
/**
* Do an action on base object
* @param[in] index The property index.
* @param[in] value The value to set.
*/
- void SetProperty( BaseObject *object, Property::Index index, const Property::Value& value ) const;
+ void SetProperty(BaseObject* object, Property::Index index, Property::Value value) const;
/**
* Sets the value of a property with the name specified for the given object.
* @param[in] name The property name.
* @param[in] value The value to set.
*/
- void SetProperty( BaseObject *object, const std::string& name, const Property::Value& value ) const;
+ void SetProperty(BaseObject* object, const std::string& name, Property::Value value) const;
/**
* Retrieves the value of a property at the index specified for the given object.
struct RegisteredProperty
{
- RegisteredProperty( Property::Type propType, const std::string& propName, Property::Index basePropertyIndex, int32_t componentIndex )
- : type( propType ),
- setFunc( nullptr ),
- getFunc( nullptr ),
- name( propName ),
- basePropertyIndex(basePropertyIndex),
- componentIndex(componentIndex)
+ RegisteredProperty(Property::Type propType, std::string propName, Property::Index basePropertyIndex, int32_t componentIndex)
+ : type(propType),
+ setFunc(nullptr),
+ getFunc(nullptr),
+ name(std::move(propName)),
+ basePropertyIndex(basePropertyIndex),
+ componentIndex(componentIndex)
{
}
-
- RegisteredProperty( Property::Type propType, Dali::TypeInfo::SetPropertyFunction set, Dali::TypeInfo::GetPropertyFunction get, const std::string& propName, Property::Index basePropertyIndex, int componentIndex )
- : type( propType ),
- setFunc( set ),
- getFunc( get ),
- name( propName ),
+ RegisteredProperty(Property::Type propType, Dali::TypeInfo::SetPropertyFunction set, Dali::TypeInfo::GetPropertyFunction get, std::string propName, Property::Index basePropertyIndex, int componentIndex)
+ : type(propType),
+ setFunc(set),
+ getFunc(get),
+ name(std::move(propName)),
basePropertyIndex(basePropertyIndex),
componentIndex(componentIndex)
{
}
- RegisteredProperty( Property::Type propType, Dali::CSharpTypeInfo::SetPropertyFunction set, Dali::CSharpTypeInfo::GetPropertyFunction get, const std::string& propName, Property::Index basePropertyIndex, int componentIndex )
- : type( propType ),
- cSharpSetFunc( set ),
- cSharpGetFunc( get ),
- name( propName ),
+ RegisteredProperty(Property::Type propType, Dali::CSharpTypeInfo::SetPropertyFunction set, Dali::CSharpTypeInfo::GetPropertyFunction get, std::string propName, Property::Index basePropertyIndex, int componentIndex)
+ : type(propType),
+ cSharpSetFunc(set),
+ cSharpGetFunc(get),
+ name(std::move(propName)),
basePropertyIndex(basePropertyIndex),
componentIndex(componentIndex)
{
int32_t componentIndex = Property::INVALID_COMPONENT_INDEX;
};
- typedef std::pair<std::string, Dali::TypeInfo::SignalConnectorFunction > ConnectionPair;
- typedef std::pair<std::string, Dali::TypeInfo::ActionFunction > ActionPair;
- typedef std::pair<Property::Index, RegisteredProperty> RegisteredPropertyPair;
- typedef std::pair<Property::Index, Property::Value> PropertyDefaultValuePair;
+ using ConnectionPair = std::pair<std::string, Dali::TypeInfo::SignalConnectorFunction>;
+ using ActionPair = std::pair<std::string, Dali::TypeInfo::ActionFunction>;
+ using RegisteredPropertyPair = std::pair<Property::Index, RegisteredProperty>;
+ using PropertyDefaultValuePair = std::pair<Property::Index, Property::Value>;
- typedef std::vector< ActionPair > ActionContainer;
- typedef std::vector< ConnectionPair > ConnectorContainer;
- typedef std::vector< RegisteredPropertyPair > RegisteredPropertyContainer;
- typedef std::vector< PropertyDefaultValuePair > PropertyDefaultValueContainer;
+ using ActionContainer = std::vector<ActionPair>;
+ using ConnectorContainer = std::vector<ConnectionPair>;
+ using RegisteredPropertyContainer = std::vector<RegisteredPropertyPair>;
+ using PropertyDefaultValueContainer = std::vector<PropertyDefaultValuePair>;
/**
* Append properties from registeredProperties onto indices.
return static_cast<uint32_t>( mRegistryLut.size() );
}
-std::string TypeRegistry::GetTypeName( uint32_t index ) const
+const std::string& TypeRegistry::GetTypeName(uint32_t index) const
{
- std::string name;
+ static std::string EMPTY_STRING{};
if( index < mRegistryLut.size() )
{
- name = mRegistryLut[ index ]->GetName();
+ return mRegistryLut[index]->GetName();
}
- return name;
+ return EMPTY_STRING;
}
std::string TypeRegistry::Register( const std::type_info& theTypeInfo,
return Register( uniqueTypeName, baseTypeInfo, createInstance, callCreateOnInit, defaultProperties, defaultPropertyCount );
}
-std::string TypeRegistry::Register( const std::string& uniqueTypeName,
- const std::type_info& baseTypeInfo,
- Dali::TypeInfo::CreateFunction createInstance,
- bool callCreateOnInit,
- const Dali::PropertyDetails* defaultProperties,
- Property::Index defaultPropertyCount )
+std::string TypeRegistry::Register(std::string uniqueTypeName,
+ const std::type_info& baseTypeInfo,
+ Dali::TypeInfo::CreateFunction createInstance,
+ bool callCreateOnInit,
+ const Dali::PropertyDetails* defaultProperties,
+ Property::Index defaultPropertyCount)
{
std::string baseTypeName = DemangleClassName( baseTypeInfo.name() );
return uniqueTypeName;
}
-void TypeRegistry::Register( const std::string& uniqueTypeName, const std::type_info& baseTypeInfo,
- Dali::CSharpTypeInfo::CreateFunction createInstance )
+void TypeRegistry::Register(std::string uniqueTypeName, const std::type_info& baseTypeInfo, Dali::CSharpTypeInfo::CreateFunction createInstance)
{
std::string baseTypeName = DemangleClassName( baseTypeInfo.name() );
return DemangleClassName( registerType.name() );
}
-void TypeRegistry::RegisterSignal( TypeRegistration& typeRegistration, const std::string& name, Dali::TypeInfo::SignalConnectorFunction func )
+void TypeRegistry::RegisterSignal(TypeRegistration& typeRegistration, std::string name, Dali::TypeInfo::SignalConnectorFunction func)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == typeRegistration.RegisteredName() )
{
- iter->AddConnectorFunction( name, func );
+ iter->AddConnectorFunction(std::move(name), func);
break;
}
}
}
-bool TypeRegistry::RegisterAction( TypeRegistration& typeRegistration, const std::string &name, Dali::TypeInfo::ActionFunction f )
+bool TypeRegistry::RegisterAction(TypeRegistration& typeRegistration, std::string name, Dali::TypeInfo::ActionFunction f)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == typeRegistration.RegisteredName() )
{
- iter->AddActionFunction( name, f );
+ iter->AddActionFunction(std::move(name), f);
return true;
}
}
return false;
}
-bool TypeRegistry::RegisterProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc )
+bool TypeRegistry::RegisterProperty(TypeRegistration& typeRegistration, std::string name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == typeRegistration.RegisteredName() )
{
- iter->AddProperty( name, index, type, setFunc, getFunc );
+ iter->AddProperty(std::move(name), index, type, setFunc, getFunc);
return true;
}
}
return false;
}
-bool TypeRegistry::RegisterProperty( const std::string& objectName, const std::string& name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc )
+bool TypeRegistry::RegisterProperty(const std::string& objectName, std::string name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == objectName )
{
- iter->AddProperty( name, index, type, setFunc, getFunc );
+ iter->AddProperty(std::move(name), index, type, setFunc, getFunc);
return true;
}
}
return false;
}
-
-bool TypeRegistry::RegisterAnimatableProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Type type )
+bool TypeRegistry::RegisterAnimatableProperty(TypeRegistration& typeRegistration, std::string name, Property::Index index, Property::Type type)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == typeRegistration.RegisteredName() )
{
- iter->AddAnimatableProperty( name, index, type );
+ iter->AddAnimatableProperty(std::move(name), index, type);
return true;
}
}
return false;
}
-bool TypeRegistry::RegisterAnimatableProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, const Property::Value& value )
+bool TypeRegistry::RegisterAnimatableProperty(TypeRegistration& typeRegistration, std::string name, Property::Index index, Property::Value value)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == typeRegistration.RegisteredName() )
{
- iter->AddAnimatableProperty( name, index, value );
+ iter->AddAnimatableProperty(std::move(name), index, std::move(value));
return true;
}
}
return false;
}
-bool TypeRegistry::RegisterAnimatablePropertyComponent( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex )
+bool TypeRegistry::RegisterAnimatablePropertyComponent(TypeRegistration& typeRegistration, std::string name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == typeRegistration.RegisteredName() )
{
- iter->AddAnimatablePropertyComponent( name, index, baseIndex, componentIndex );
+ iter->AddAnimatablePropertyComponent(std::move(name), index, baseIndex, componentIndex);
return true;
}
}
return false;
}
-bool TypeRegistry::RegisterChildProperty( const std::string& registeredType, const std::string& name, Property::Index index, Property::Type type )
+bool TypeRegistry::RegisterChildProperty(const std::string& registeredType, std::string name, Property::Index index, Property::Type type)
{
for( auto&& iter : mRegistryLut )
{
if( iter->GetName() == registeredType )
{
- iter->AddChildProperty( name, index, type );
+ iter->AddChildProperty(std::move(name), index, type);
return true;
}
}
return false;
}
-bool TypeRegistry::RegisterChildProperty( TypeRegistration& typeRegistration, const std::string& name, Property::Index index, Property::Type type )
+bool TypeRegistry::RegisterChildProperty(TypeRegistration& typeRegistration, std::string name, Property::Index index, Property::Type type)
{
- return RegisterChildProperty( typeRegistration.RegisteredName(), name, index, type );
+ return RegisterChildProperty(typeRegistration.RegisteredName(), std::move(name), index, type);
}
bool TypeRegistry::DoActionTo( BaseObject * const object, const std::string& actionName, const Property::Map& properties )
/**
* @copydoc Dali::TypeRegistry::GetTypeName
*/
- std::string GetTypeName( uint32_t index ) const;
+ const std::string& GetTypeName(uint32_t index) const;
/**
* Register a type
* @param [in] defaultPropertyCount count of default properties
* @return the name of the registered type.
*/
- std::string Register( const std::string& name, const std::type_info& baseTypeInfo,
- Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit,
- const Dali::PropertyDetails* defaultProperties = nullptr, Property::Index defaultPropertyCount = 0 );
+ std::string Register(std::string name, const std::type_info& baseTypeInfo, Dali::TypeInfo::CreateFunction createInstance, bool callCreateOnInit, const Dali::PropertyDetails* defaultProperties = nullptr, Property::Index defaultPropertyCount = 0);
/**
* @copydoc CSharpTypeRegistry::TypeRegistration( const std::string&, const std::type_info&, TypeInfo::CreateFunction );
*/
- void Register( const std::string& name, const std::type_info& baseTypeInfo,
- Dali::CSharpTypeInfo::CreateFunction createInstance );
+ void Register(std::string name, const std::type_info& baseTypeInfo, Dali::CSharpTypeInfo::CreateFunction createInstance);
/**
* Register a signal connector function to a type
* @param [in] name Signal name
* @param [in] func Signal connector function
*/
- void RegisterSignal( TypeRegistration& typeRegistration, const std::string& name, Dali::TypeInfo::SignalConnectorFunction func );
+ void RegisterSignal(TypeRegistration& typeRegistration, std::string name, Dali::TypeInfo::SignalConnectorFunction func);
/**
* Register an action function to a type
* @param [in] f Action function
* @return true if registered
*/
- bool RegisterAction( TypeRegistration& registered, const std::string& name, Dali::TypeInfo::ActionFunction f );
+ bool RegisterAction(TypeRegistration& registered, std::string name, Dali::TypeInfo::ActionFunction f);
/**
* Register an event-thread only property with a type
* @param [in] getFunc The function to get the value of a property.
* @return true if registered
*/
- bool RegisterProperty( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc );
+ bool RegisterProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type, Dali::TypeInfo::SetPropertyFunction setFunc, Dali::TypeInfo::GetPropertyFunction getFunc);
/**
* Register an event-thread only property with a type (used by C# Custom controls)
* @param [in] getFunc The function to get the value of a property.
* @return true if registered
*/
- bool RegisterProperty( const std::string& objectName, const std::string& name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc );
-
+ bool RegisterProperty(const std::string& objectName, std::string name, Property::Index index, Property::Type type, Dali::CSharpTypeInfo::SetPropertyFunction setFunc, Dali::CSharpTypeInfo::GetPropertyFunction getFunc);
/**
* Register a scene graph only property with a type
* @param [in] type Property type
* @return true if registered
*/
- bool RegisterAnimatableProperty( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type );
+ bool RegisterAnimatableProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type);
/**
* Register a scene graph only property with a default value
* @param [in] value Property default value
* @return true if registered
*/
- bool RegisterAnimatableProperty( TypeRegistration& registered, const std::string& name, Property::Index index, const Property::Value& defaultValue );
+ bool RegisterAnimatableProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Value defaultValue);
/**
* Register a component of a scene graph only property that supports components (i.e. Vector2, Vector3 and Vector4)
* @param [in] componentIndex Component index
* @return true if registered
*/
- bool RegisterAnimatablePropertyComponent( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex );
+ bool RegisterAnimatablePropertyComponent(TypeRegistration& registered, std::string name, Property::Index index, Property::Index baseIndex, unsigned int componentIndex);
/**
* Register a event-thread only property with a type and a default value
* @param [in] type Property type
* @return true if registered
*/
- bool RegisterChildProperty( const std::string& registeredType, const std::string& name, Property::Index index, Property::Type type );
+ bool RegisterChildProperty(const std::string& registeredType, std::string name, Property::Index index, Property::Type type);
/**
* Register a event-thread only property with a type and a default value
* @param [in] type Property type
* @return true if registered
*/
- bool RegisterChildProperty( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type );
+ bool RegisterChildProperty(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type);
/**
* @copydoc Dali::Internal::TypeInfo::DoActionTo
private:
TypeRegistry();
- ~TypeRegistry();
+ ~TypeRegistry() override;
/**
* @brief Undefined Copy Constructor
}
// If memory cache failed check the file system for a binary or return a source-only ShaderData:
- if( shaderData.Get() == NULL )
+ if( shaderData.Get() == nullptr )
{
// Allocate the structure that returns the loaded shader:
shaderData = new ShaderData( vertexSource, fragmentSource, hints );
{
class ShaderData;
-typedef IntrusivePtr<ShaderData> ShaderDataPtr;
+using ShaderDataPtr = IntrusivePtr<ShaderData>;
/**
* @brief ShaderFactory loads and saves shader binaries synchronously.
/**
* Destructor
*/
- virtual ~ShaderFactory();
+ ~ShaderFactory() override;
/**
* @brief Looks for precompiled binary version of shader program in memory and file caches.
* @param[in] shader The data to be saved.
* @sa Load
*/
- virtual void SaveBinary( Internal::ShaderDataPtr shader );
+ void SaveBinary( Internal::ShaderDataPtr shader ) override;
private:
const GestureType::Value type( detector.GetType() );
GestureDetectorContainer*& containerPtr( GetContainerPtr( type ) );
- if ( NULL == containerPtr )
+ if ( nullptr == containerPtr )
{
containerPtr = new GestureDetectorContainer;
}
{
gesturesRequired = GestureType::Value( gesturesRequired & ~type );
delete containerPtr;
- containerPtr = NULL;
+ containerPtr = nullptr;
}
}
}
DALI_ASSERT_DEBUG( ! "Invalid Type" );
- static GestureDetectorContainer* invalidType( NULL );
+ static GestureDetectorContainer* invalidType( nullptr );
return invalidType;
}
/**
* Non virtual destructor
*/
- ~ActorObserver();
+ ~ActorObserver() override;
// Movable
* @param[in] object The object object.
* @see Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded( Object& object );
+ void SceneObjectAdded( Object& object ) override;
/**
* This will be called when the actor is removed from the scene.
* @param[in] object The object object.
* @see Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved( Object& object );
+ void SceneObjectRemoved( Object& object ) override;
/**
* This will be called when the actor is destroyed. We should clear the actor.
* No need to stop observing as the object is being destroyed anyway.
* @see Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed( Object& object );
+ void ObjectDestroyed( Object& object ) override;
private:
Actor* mActor; ///< Raw pointer to an Actor.
case Event::Hover:
{
- typedef Integration::HoverEvent DerivedType;
+ using DerivedType = Integration::HoverEvent;
// Reserve some memory inside the message queue
uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
case Event::Key:
{
- typedef Integration::KeyEvent DerivedType;
+ using DerivedType = Integration::KeyEvent;
// Reserve some memory inside the message queue
uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
case Event::Wheel:
{
- typedef Integration::WheelEvent DerivedType;
+ using DerivedType = Integration::WheelEvent;
// Reserve some memory inside the message queue
uint32_t* slot = mCurrentEventQueue->ReserveMessageSlot( sizeof( DerivedType ) );
class GestureDetector;
class GestureEventProcessor;
-typedef IntrusivePtr<GestureDetector> GestureDetectorPtr;
-typedef std::vector<GestureDetector*> GestureDetectorContainer;
-typedef std::vector<Actor*> GestureDetectorActorContainer;
+using GestureDetectorPtr = IntrusivePtr<GestureDetector>;
+using GestureDetectorContainer = std::vector<GestureDetector*>;
+using GestureDetectorActorContainer = std::vector<Actor*>;
/**
* This is a type trait that should be used by deriving gesture detectors for their container type.
template< typename Detector >
struct DerivedGestureDetectorContainer
{
- typedef std::vector<Detector*> type;
+ using type = std::vector<Detector*>;
};
/**
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~GestureDetector();
+ ~GestureDetector() override;
private:
/**
* @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded(Object& object);
+ void SceneObjectAdded(Object& object) override;
/**
* @copydoc Dali::Internal::Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectRemoved(Object& object) {}
+ void SceneObjectRemoved(Object& object) override {}
/**
* @copydoc Dali::Internal::Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed(Object& object);
+ void ObjectDestroyed(Object& object) override;
/**
* For use in derived classes, called after an actor is attached.
{
class Gesture;
-typedef IntrusivePtr<Gesture> GesturePtr;
+using GesturePtr = IntrusivePtr<Gesture>;
/**
* This is the abstract base structure for any gestures that the adaptor detects and wishes to send
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Gesture() = default;
+ ~Gesture() override = default;
private:
GestureType::Value mGestureType;
#include <dali/internal/event/common/scene-impl.h>
#include <dali/internal/event/events/hit-test-algorithm-impl.h>
#include <dali/internal/event/events/actor-gesture-data.h>
+#include <dali/internal/event/events/ray-test.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
namespace Dali
{
}
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->IsGestureRequired( mType ) && // Does the Application or derived actor type require the gesture?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsTouchConsumed();
}
{
Actor* hitTestActor( &GetImplementation( hitTestResults.actor ) );
Actor* actor( hitTestActor );
+ RayTest rayTest;
while ( actor )
{
if ( ( size.x > 0.0f ) && ( size.y > 0.0f ) )
{
// Ensure tap is within the actor's area
- if ( actor->RaySphereTest( hitTestResults.rayOrigin, hitTestResults.rayDirection ) ) // Quick check
+ if ( rayTest.SphereTest( *actor, hitTestResults.rayOrigin, hitTestResults.rayDirection ) ) // Quick check
{
Vector2 hitPointLocal;
float distance( 0.0f );
- if( actor->RayActorTest( hitTestResults.rayOrigin, hitTestResults.rayDirection, hitPointLocal, distance ) )
+ if( rayTest.ActorTest( *actor, hitTestResults.rayOrigin, hitTestResults.rayDirection, hitPointLocal, distance ) )
{
// One of the parents was the gestured actor so we can emit the signal for that actor.
EmitGestureSignal( actor, gestureDetectors, hitPointLocal );
/**
* Virtual protected destructor.
*/
- virtual ~GestureProcessor();
+ ~GestureProcessor() override;
// Methods to be used by deriving classes
* @param[in] object The object object.
* @see Object::Observer::SceneObjectAdded()
*/
- virtual void SceneObjectAdded(Object& object) { }
+ void SceneObjectAdded(Object& object) override { }
/**
* This will be called when the actor is removed from the stage, we should clear and stop
* @param[in] object The object object.
* @see Object::Observer::SceneObjectRemoved()
*/
- virtual void SceneObjectRemoved(Object& object);
+ void SceneObjectRemoved(Object& object) override;
/**
* This will be called when the actor is destroyed. We should clear the actor.
* No need to stop observing as the object is being destroyed anyway.
* @see Object::Observer::ObjectDestroyed()
*/
- virtual void ObjectDestroyed(Object& object);
+ void ObjectDestroyed(Object& object) override;
protected: //Data
/**
* Virtual destructor.
*/
- virtual ~GestureRecognizer() {}
+ ~GestureRecognizer() override {}
protected:
Vector2 mScreenSize;
Scene* mScene;
};
-typedef IntrusivePtr<GestureRecognizer> GestureRecognizerPtr;
+using GestureRecognizerPtr = IntrusivePtr<GestureRecognizer>;
} // namespace Internal
/**
* Virtual destructor
*/
- virtual ~PanGestureRequest()
+ ~PanGestureRequest() override
{
}
/**
* Virtual destructor
*/
- virtual ~TapGestureRequest()
+ ~TapGestureRequest() override
{
}
/**
* Virtual destructor
*/
- virtual ~LongPressGestureRequest()
+ ~LongPressGestureRequest() override
{
}
#include <dali/internal/event/actors/layer-impl.h>
#include <dali/internal/event/actors/layer-list.h>
#include <dali/internal/event/common/projection.h>
+#include <dali/internal/event/events/ray-test.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
#include <dali/internal/event/render-tasks/render-task-list-impl.h>
struct HitActor
{
HitActor()
- : actor( NULL ),
+ : actor( nullptr ),
distance( std::numeric_limits<float>::max() ),
depth( std::numeric_limits<int>::min() )
{
{
}
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::CHECK_ACTOR );
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return mFunc( Dali::Actor( actor ), Dali::HitTestAlgorithm::DESCEND_ACTOR_TREE );
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
// Layer::IsTouchConsumed() focuses on touch only. Here we are a wrapper for the public-api
// where the caller may want to check for something completely different.
*/
struct ActorTouchableCheck : public HitTestInterface
{
- virtual bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->GetTouchRequired() && // Does the Application or derived actor type require a touch event?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- virtual bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- virtual bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsTouchConsumed();
}
bool& overlayHit,
bool layerIs3d,
uint32_t clippingDepth,
- uint32_t clippingBitPlaneMask )
+ uint32_t clippingBitPlaneMask,
+ const RayTest& rayTest )
{
HitActor hit;
// Ensure the actor has a valid size.
// If so, perform a quick ray sphere test to see if our ray is close to the actor.
- if( size.x > 0.0f && size.y > 0.0f && actor.RaySphereTest( rayOrigin, rayDir ) )
+ if( size.x > 0.0f && size.y > 0.0f && rayTest.SphereTest( actor, rayOrigin, rayDir ) )
{
Vector2 hitPointLocal;
float distance;
// Finally, perform a more accurate ray test to see if our ray actually hits the actor.
- if( actor.RayActorTest( rayOrigin, rayDir, hitPointLocal, distance ) )
+ if( rayTest.ActorTest( actor, rayOrigin, rayDir, hitPointLocal, distance ) )
{
if( distance >= nearClippingPlane && distance <= farClippingPlane )
{
overlayHit,
layerIs3d,
newClippingDepth,
- clippingBitPlaneMask ) );
+ clippingBitPlaneMask,
+ rayTest ) );
bool updateChildHit = false;
if( currentHit.distance >= 0.0f )
RenderTask& renderTask,
Vector2 screenCoordinates,
Results& results,
- HitTestInterface& hitCheck )
+ HitTestInterface& hitCheck,
+ const RayTest& rayTest )
{
if ( renderTask.IsHittable( screenCoordinates ) )
{
overlayHit,
layer->GetBehavior() == Dali::Layer::LAYER_3D,
0u,
- 0u );
+ 0u,
+ rayTest );
}
else if( IsWithinSourceActors( *sourceActor, *layer ) )
{
overlayHit,
layer->GetBehavior() == Dali::Layer::LAYER_3D,
0u,
- 0u );
+ 0u,
+ rayTest );
}
// If this layer is set to consume the hit, then do not check any layers behind it
RenderTaskList::RenderTaskContainer& tasks = taskList.GetTasks();
RenderTaskList::RenderTaskContainer::reverse_iterator endIter = tasks.rend();
const auto& exclusives = taskList.GetExclusivesList();
+ RayTest rayTest;
for( RenderTaskList::RenderTaskContainer::reverse_iterator iter = tasks.rbegin(); endIter != iter; ++iter )
{
continue;
}
- if( HitTestRenderTask( exclusives, sceneSize, layers, renderTask, screenCoordinates, results, hitCheck ) )
+ if( HitTestRenderTask( exclusives, sceneSize, layers, renderTask, screenCoordinates, results, hitCheck, rayTest ) )
{
// Return true when an actor is hit (or layer in our render-task consumes the hit)
return true; // don't bother checking off screen tasks
{
class HoverEvent;
-typedef IntrusivePtr< HoverEvent > HoverEventPtr;
+using HoverEventPtr = IntrusivePtr<HoverEvent>;
/**
* @copydoc Dali::HoverEvent
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~HoverEvent() = default;
+ ~HoverEvent() override = default;
// Not copyable or movable
*/
struct ActorHoverableCheck : public HitTestAlgorithm::HitTestInterface
{
- bool IsActorHittable( Actor* actor )
+ bool IsActorHittable( Actor* actor ) override
{
return actor->GetHoverRequired() && // Does the Application or derived actor type require a hover event?
actor->IsHittable(); // Is actor sensitive, visible and on the scene?
}
- bool DescendActorHierarchy( Actor* actor )
+ bool DescendActorHierarchy( Actor* actor ) override
{
return actor->IsVisible() && // Actor is visible, if not visible then none of its children are visible.
actor->IsSensitive(); // Actor is sensitive, if insensitive none of its children should be hittable either.
}
- bool DoesLayerConsumeHit( Layer* layer )
+ bool DoesLayerConsumeHit( Layer* layer ) override
{
return layer->IsHoverConsumed();
}
AllocAndEmitHoverSignals( event.time, hoverStartConsumedActorHandle, currentPoint );
}
- mLastPrimaryHitActor.SetActor( NULL );
- mLastConsumedActor.SetActor( NULL );
- mHoverStartConsumedActor.SetActor( NULL );
+ mLastPrimaryHitActor.SetActor( nullptr );
+ mLastConsumedActor.SetActor( nullptr );
+ mHoverStartConsumedActor.SetActor( nullptr );
mLastRenderTask.Reset();
return; // No need for hit testing
if ( primaryPointState == PointState::FINISHED )
{
- mLastPrimaryHitActor.SetActor( NULL );
- mLastConsumedActor.SetActor( NULL );
+ mLastPrimaryHitActor.SetActor( nullptr );
+ mLastConsumedActor.SetActor( nullptr );
mLastRenderTask.Reset();
}
else
}
else
{
- mLastConsumedActor.SetActor( NULL );
+ mLastConsumedActor.SetActor( nullptr );
}
mLastRenderTask = currentRenderTask;
}
else
{
- mLastPrimaryHitActor.SetActor( NULL );
- mLastConsumedActor.SetActor( NULL );
+ mLastPrimaryHitActor.SetActor( nullptr );
+ mLastConsumedActor.SetActor( nullptr );
mLastRenderTask.Reset();
}
}
primaryPoint.SetState( primaryPointState );
}
- mHoverStartConsumedActor.SetActor( NULL );
+ mHoverStartConsumedActor.SetActor( nullptr );
}
// No break, Fallthrough
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~KeyEvent() = default;
+ ~KeyEvent() override = default;
// Not copyable or movable
class LongPressGestureDetector;
-typedef IntrusivePtr<LongPressGestureDetector> LongPressGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<LongPressGestureDetector>::type LongPressGestureDetectorContainer;
+using LongPressGestureDetectorPtr = IntrusivePtr<LongPressGestureDetector>;
+using LongPressGestureDetectorContainer = DerivedGestureDetectorContainer<LongPressGestureDetector>::type;
/**
* @copydoc Dali::LongPressGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~LongPressGestureDetector();
+ ~LongPressGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~LongPressGestureEvent();
+ ~LongPressGestureEvent() override;
// Data
{
class LongPressGesture;
-typedef IntrusivePtr< LongPressGesture > LongPressGesturePtr;
+using LongPressGesturePtr = IntrusivePtr<LongPressGesture>;
/**
* @copydoc Dali::LongPressGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~LongPressGesture() = default;
+ ~LongPressGesture() override = default;
private:
Vector2 mScreenPoint;
mCurrentRenderTask(),
mMinTouchesRequired( 1 ),
mMaxTouchesRequired( 1 ),
- mCurrentLongPressEvent( NULL ),
+ mCurrentLongPressEvent( nullptr ),
mMinimumHoldingTime( DEFAULT_MINIMUM_HOLDING_TIME )
{
}
// Set mCurrentLongPressEvent to use inside overridden methods called from ProcessAndEmit()
mCurrentLongPressEvent = &longPressEvent;
ProcessAndEmit( hitTestResults );
- mCurrentLongPressEvent = NULL;
+ mCurrentLongPressEvent = nullptr;
}
else
{
/**
* Non-virtual destructor; LongPressGestureProcessor is not a base class
*/
- ~LongPressGestureProcessor();
+ ~LongPressGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the long press gesture event occurs in.
* @param[in] longPressEvent The event that has occurred.
*/
- void Process( Scene& scene, const LongPressGestureEvent& longPressEvent );
+ void Process( Scene& scene, const LongPressGestureEvent& longPressEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~LongPressGestureRecognizer();
+ ~LongPressGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
/**
* @brief This method sets the minimum holding time required to be recognized as a long press gesture
{
class PanGestureDetector;
-typedef IntrusivePtr<PanGestureDetector> PanGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<PanGestureDetector>::type PanGestureDetectorContainer;
+using PanGestureDetectorPtr = IntrusivePtr<PanGestureDetector>;
+using PanGestureDetectorContainer = DerivedGestureDetectorContainer<PanGestureDetector>::type;
namespace SceneGraph
{
class PanGestureDetector : public GestureDetector
{
public: // Typedefs
-
- typedef Dali::PanGestureDetector::AngleThresholdPair AngleThresholdPair;
- typedef std::vector<AngleThresholdPair> AngleContainer;
+ using AngleThresholdPair = Dali::PanGestureDetector::AngleThresholdPair;
+ using AngleContainer = std::vector<AngleThresholdPair>;
public: // Creation
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PanGestureDetector();
+ ~PanGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
// Default property extensions from Object
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
private:
/**
* Virtual destructor
*/
- virtual ~PanGestureEvent();
+ ~PanGestureEvent() override;
// Data
{
class PanGesture;
-typedef IntrusivePtr< PanGesture > PanGesturePtr;
+using PanGesturePtr = IntrusivePtr<PanGesture>;
/**
* @copydoc Dali::PanGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PanGesture() = default;
+ ~PanGesture() override = default;
private:
Vector2 mVelocity;
/**
* Destructor
*/
- virtual ~PanGestureProcessor();
+ ~PanGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the pan gesture event occurs in.
* @param[in] panEvent The event that has occurred.
*/
- void Process( Scene& scene, const PanGestureEvent& panEvent );
+ void Process( Scene& scene, const PanGestureEvent& panEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~PanGestureRecognizer();
+ ~PanGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
class PinchGestureDetector;
-typedef IntrusivePtr<PinchGestureDetector> PinchGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<PinchGestureDetector>::type PinchGestureDetectorContainer;
+using PinchGestureDetectorPtr = IntrusivePtr<PinchGestureDetector>;
+using PinchGestureDetectorContainer = DerivedGestureDetectorContainer<PinchGestureDetector>::type;
/**
* @copydoc Dali::PinchGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PinchGestureDetector();
+ ~PinchGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~PinchGestureEvent();
+ ~PinchGestureEvent() override;
// Data
{
class PinchGesture;
-typedef IntrusivePtr< PinchGesture > PinchGesturePtr;
+using PinchGesturePtr = IntrusivePtr<PinchGesture>;
/**
* @copydoc Dali::PinchGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~PinchGesture() = default;
+ ~PinchGesture() override = default;
private:
Vector2 mScreenCenterPoint;
: GestureProcessor( GestureType::PINCH ),
mPinchGestureDetectors(),
mCurrentPinchEmitters(),
- mCurrentPinchEvent(NULL),
+ mCurrentPinchEvent(nullptr),
mMinimumPinchDistance(-1.0f),
mMinimumTouchEvents( MINIMUM_TOUCH_EVENTS_REQUIRED ),
mMinimumTouchEventsAfterStart( MINIMUM_TOUCH_EVENTS_REQUIRED_AFTER_START )
// Set mCurrentPinchEvent to use inside overridden methods called from ProcessAndEmit()
mCurrentPinchEvent = &pinchEvent;
ProcessAndEmit( hitTestResults );
- mCurrentPinchEvent = NULL;
+ mCurrentPinchEvent = nullptr;
}
break;
}
/**
* Non-virtual destructor; PinchGestureProcessor is not a base class
*/
- ~PinchGestureProcessor();
+ ~PinchGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the pinch gesture event occurs in.
* @param[in] pinchEvent The event that has occurred.
*/
- void Process( Scene& scene, const PinchGestureEvent& pinchEvent );
+ void Process( Scene& scene, const PinchGestureEvent& pinchEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~PinchGestureRecognizer();
+ ~PinchGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
--- /dev/null
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/events/ray-test.h>
+
+// INTERNAL INCLUDES
+#include <dali/public-api/math/vector2.h>
+#include <dali/public-api/math/vector3.h>
+#include <dali/public-api/math/vector4.h>
+#include <dali/internal/event/actors/actor-impl.h>
+#include <dali/internal/event/common/event-thread-services.h>
+#include <dali/internal/update/nodes/node.h>
+
+using Dali::Internal::SceneGraph::Node;
+
+namespace Dali
+{
+
+namespace Internal
+{
+
+RayTest::RayTest()
+: mEventThreadServices( EventThreadServices::Get() )
+{
+}
+
+bool RayTest::SphereTest( const Internal::Actor& actor, const Vector4& rayOrigin, const Vector4& rayDir ) const
+{
+ /*
+ http://wiki.cgsociety.org/index.php/Ray_Sphere_Intersection
+
+ Mathematical Formulation
+
+ Given the above mentioned sphere, a point 'p' lies on the surface of the sphere if
+
+ ( p - c ) dot ( p - c ) = r^2
+
+ Given a ray with a point of origin 'o', and a direction vector 'd':
+
+ ray(t) = o + td, t >= 0
+
+ we can find the t at which the ray intersects the sphere by setting ray(t) equal to 'p'
+
+ (o + td - c ) dot ( o + td - c ) = r^2
+
+ To solve for t we first expand the above into a more recognisable quadratic equation form
+
+ ( d dot d )t^2 + 2( o - c ) dot dt + ( o - c ) dot ( o - c ) - r^2 = 0
+
+ or
+
+ At2 + Bt + C = 0
+
+ where
+
+ A = d dot d
+ B = 2( o - c ) dot d
+ C = ( o - c ) dot ( o - c ) - r^2
+
+ which can be solved using a standard quadratic formula.
+
+ Note that in the absence of positive, real, roots, the ray does not intersect the sphere.
+
+ Practical Simplification
+
+ In a renderer, we often differentiate between world space and object space. In the object space
+ of a sphere it is centred at origin, meaning that if we first transform the ray from world space
+ into object space, the mathematical solution presented above can be simplified significantly.
+
+ If a sphere is centred at origin, a point 'p' lies on a sphere of radius r2 if
+
+ p dot p = r^2
+
+ and we can find the t at which the (transformed) ray intersects the sphere by
+
+ ( o + td ) dot ( o + td ) = r^2
+
+ According to the reasoning above, we expand the above quadratic equation into the general form
+
+ At2 + Bt + C = 0
+
+ which now has coefficients:
+
+ A = d dot d
+ B = 2( d dot o )
+ C = o dot o - r^2
+ */
+
+ // Early out if not on the scene
+ if( ! actor.OnScene() )
+ {
+ return false;
+ }
+
+ const Node& node = actor.GetNode();
+ const BufferIndex bufferIndex = EventThreadServices::Get().GetEventBufferIndex();
+ const Vector3& translation = node.GetWorldPosition( bufferIndex );
+ const Vector3& size = node.GetSize( bufferIndex );
+ const Vector3& scale = node.GetWorldScale( bufferIndex );
+
+ // Transforms the ray to the local reference system. As the test is against a sphere, only the translation and scale are needed.
+ const Vector3 rayOriginLocal( rayOrigin.x - translation.x, rayOrigin.y - translation.y, rayOrigin.z - translation.z );
+
+ // Computing the radius is not needed, a square radius is enough so can just use size but we do need to scale the sphere
+ const float width = size.width * scale.width;
+ const float height = size.height * scale.height;
+
+ float squareSphereRadius = 0.5f * ( width * width + height * height );
+
+ float a = rayDir.Dot( rayDir ); // a
+ float b2 = rayDir.Dot( rayOriginLocal ); // b/2
+ float c = rayOriginLocal.Dot( rayOriginLocal ) - squareSphereRadius; // c
+
+ return ( b2 * b2 - a * c ) >= 0.0f;
+}
+
+
+bool RayTest::ActorTest(const Internal::Actor& actor, const Vector4& rayOrigin, const Vector4& rayDir, Vector2& hitPointLocal, float& distance) const
+{
+ bool hit = false;
+
+ if(actor.OnScene())
+ {
+ const Node& node = actor.GetNode();
+
+ // Transforms the ray to the local reference system.
+ // Calculate the inverse of Model matrix
+ Matrix invModelMatrix( false/*don't init*/);
+ invModelMatrix = node.GetWorldMatrix(0);
+ invModelMatrix.Invert();
+
+ Vector4 rayOriginLocal(invModelMatrix * rayOrigin);
+ Vector4 rayDirLocal(invModelMatrix * rayDir - invModelMatrix.GetTranslation());
+
+ // Test with the actor's XY plane (Normal = 0 0 1 1).
+ float a = -rayOriginLocal.z;
+ float b = rayDirLocal.z;
+
+ if( fabsf( b ) > Math::MACHINE_EPSILON_1 )
+ {
+ // Ray travels distance * rayDirLocal to intersect with plane.
+ distance = a / b;
+
+ const Vector3& size = node.GetSize(EventThreadServices::Get().GetEventBufferIndex());
+ hitPointLocal.x = rayOriginLocal.x + rayDirLocal.x * distance + size.x * 0.5f;
+ hitPointLocal.y = rayOriginLocal.y + rayDirLocal.y * distance + size.y * 0.5f;
+
+ // Test with the actor's geometry.
+ hit = (hitPointLocal.x >= 0.f) && (hitPointLocal.x <= size.x) && (hitPointLocal.y >= 0.f) && (hitPointLocal.y <= size.y);
+ }
+ }
+
+ return hit;
+}
+
+} // namespace Internal
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_INTERNAL_RAY_TEST_H
+#define DALI_INTERNAL_RAY_TEST_H
+
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// CLASS HEADER
+#include <dali/internal/event/actors/actor-impl.h>
+
+namespace Dali
+{
+
+class Vector2;
+class Vector4;
+
+namespace Internal
+{
+
+class Actor;
+class EventThreadServices;
+
+/**
+ * Contains methods to perform ray tests on given actors.
+ *
+ * Stores a reference to the EventThreadServices so limit the number of times this is created
+ * to avoid repeated calls to EventThreadServices::Get().
+ */
+class RayTest
+{
+public:
+
+ /// Constructor
+ RayTest();
+
+ /// Default Destructor
+ ~RayTest() = default;
+
+ /**
+ * Performs a ray-sphere test with the given pick-ray and the given actor's bounding sphere.
+ *
+ * @param[in] actor The actor to perform the ray-sphere test on
+ * @param[in] rayOrigin The ray origin in the world's reference system
+ * @param[in] rayDir The ray director vector in the world's reference system
+ * @return True if the ray intersects the actor's bounding sphere
+ *
+ * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
+ */
+ bool SphereTest(const Internal::Actor& actor, const Vector4& rayOrigin, const Vector4& rayDir) const;
+
+ /**
+ * Performs a ray-actor test with the given pick-ray and the given actor's geometry.
+ *
+ * @param[in] actor The actor to perform the ray-sphere test on
+ * @param[in] rayOrigin The ray origin in the world's reference system.
+ * @param[in] rayDir The ray director vector in the world's reference system.
+ * @param[out] hitPointLocal The hit point in the Actor's local reference system.
+ * @param[out] distance The distance from the hit point to the camera.
+ * @return True if the ray intersects the actor's geometry.
+ *
+ * @note The actor coordinates are relative to the top-left (0.0, 0.0, 0.5)
+ */
+ bool ActorTest(const Internal::Actor& actor, const Vector4& rayOrigin, const Vector4& rayDir, Vector2& hitPointLocal, float& distance) const;
+
+private:
+ const EventThreadServices& mEventThreadServices;
+};
+
+} // namespace Internal
+
+} // namespace Dali
+
+#endif // DALI_INTERNAL_RAY_TEST_H
class RotationGestureDetector;
-typedef IntrusivePtr<RotationGestureDetector> RotationGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<RotationGestureDetector>::type RotationGestureDetectorContainer;
+using RotationGestureDetectorPtr = IntrusivePtr<RotationGestureDetector>;
+using RotationGestureDetectorContainer = DerivedGestureDetectorContainer<RotationGestureDetector>::type;
/**
* @copydoc Dali::RotationGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RotationGestureDetector() = default;
+ ~RotationGestureDetector() override = default;
private: // GestureDetector overrides
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach( Actor& actor ) { /* Nothing to do */ }
+ void OnActorAttach( Actor& actor ) override { /* Nothing to do */ }
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach( Actor& actor ) { /* Nothing to do */ }
+ void OnActorDetach( Actor& actor ) override { /* Nothing to do */ }
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed( Object& object ) { /* Nothing to do */ }
+ void OnActorDestroyed( Object& object ) override { /* Nothing to do */ }
private:
/**
* Virtual destructor
*/
- virtual ~RotationGestureEvent() = default;
+ ~RotationGestureEvent() override = default;
// Data
{
class RotationGesture;
-typedef IntrusivePtr< RotationGesture > RotationGesturePtr;
+using RotationGesturePtr = IntrusivePtr<RotationGesture>;
/**
* @copydoc Dali::RotationGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RotationGesture() = default;
+ ~RotationGesture() override = default;
private:
Radian mRotation;
// Set mCurrentRotationEvent to use inside overridden methods called from ProcessAndEmit()
mCurrentRotationEvent = &rotationEvent;
ProcessAndEmit( hitTestResults );
- mCurrentRotationEvent = NULL;
+ mCurrentRotationEvent = nullptr;
}
break;
}
/**
* Non-virtual destructor; RotationGestureProcessor is not a base class
*/
- ~RotationGestureProcessor() = default;
+ ~RotationGestureProcessor() override = default;
RotationGestureProcessor( const RotationGestureProcessor& ) = delete; ///< Deleted copy constructor.
RotationGestureProcessor& operator=( const RotationGestureProcessor& rhs ) = delete; ///< Deleted copy assignment operator.
* @param[in] scene The scene the rotation gesture event occurs in.
* @param[in] rotationEvent The event that has occurred.
*/
- void Process( Scene& scene, const RotationGestureEvent& rotationEvent );
+ void Process( Scene& scene, const RotationGestureEvent& rotationEvent ) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection();
+ void OnGesturedActorStageDisconnection() override;
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~RotationGestureRecognizer() = default;
+ ~RotationGestureRecognizer() override = default;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent( const Integration::TouchEvent& event );
+ void SendEvent( const Integration::TouchEvent& event ) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update( const GestureRequest& request ) { /* Nothing to do */ }
+ void Update( const GestureRequest& request ) override { /* Nothing to do */ }
/**
* Sets the minimum touch events required before a rotation can be started
class TapGestureDetector;
-typedef IntrusivePtr<TapGestureDetector> TapGestureDetectorPtr;
-typedef DerivedGestureDetectorContainer<TapGestureDetector>::type TapGestureDetectorContainer;
+using TapGestureDetectorPtr = IntrusivePtr<TapGestureDetector>;
+using TapGestureDetectorContainer = DerivedGestureDetectorContainer<TapGestureDetector>::type;
/**
* @copydoc Dali::TapGestureDetector
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TapGestureDetector();
+ ~TapGestureDetector() override;
private:
/**
* @copydoc Dali::Internal::GestureDetector::OnActorAttach(Actor&)
*/
- virtual void OnActorAttach(Actor& actor);
+ void OnActorAttach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDetach(Actor&)
*/
- virtual void OnActorDetach(Actor& actor);
+ void OnActorDetach(Actor& actor) override;
/**
* @copydoc Dali::Internal::GestureDetector::OnActorDestroyed(Object&)
*/
- virtual void OnActorDestroyed(Object& object);
+ void OnActorDestroyed(Object& object) override;
private:
/**
* Virtual destructor
*/
- virtual ~TapGestureEvent();
+ ~TapGestureEvent() override;
// Data
{
class TapGesture;
-typedef IntrusivePtr< TapGesture > TapGesturePtr;
+using TapGesturePtr = IntrusivePtr<TapGesture>;
/**
* @copydoc Dali::TapGesture
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TapGesture() = default;
+ ~TapGesture() override = default;
private:
Vector2 mScreenPoint;
mMaxTapsRequired( 1 ),
mMinTouchesRequired( 1 ),
mMaxTouchesRequired( 1 ),
- mCurrentTapEvent( NULL ),
+ mCurrentTapEvent( nullptr ),
mPossibleProcessed( false )
{
}
mCurrentTapEvent = &tapEvent;
ProcessAndEmit( hitTestResults );
}
- mCurrentTapEvent = NULL;
+ mCurrentTapEvent = nullptr;
mPossibleProcessed = false;
}
break;
/**
* Non-virtual destructor; TapGestureProcessor is not a base class
*/
- ~TapGestureProcessor();
+ ~TapGestureProcessor() override;
public: // To be called by GestureEventProcessor
* @param[in] scene The scene the tap gesture event occurs in.
* @param[in] tapEvent The event that has occurred.
*/
- void Process( Scene& scene, const TapGestureEvent& event);
+ void Process( Scene& scene, const TapGestureEvent& event) override;
/**
* Adds a gesture detector to this gesture processor.
/**
* @copydoc GestureProcessor::OnGesturedActorStageDisconnection()
*/
- void OnGesturedActorStageDisconnection() { /* Nothing to do */ }
+ void OnGesturedActorStageDisconnection() override { /* Nothing to do */ }
/**
* @copydoc GestureProcessor::CheckGestureDetector()
*/
- bool CheckGestureDetector( GestureDetector* detector, Actor* actor );
+ bool CheckGestureDetector( GestureDetector* detector, Actor* actor ) override;
/**
* @copydoc GestureProcessor::EmitGestureSignal()
*/
- void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates );
+ void EmitGestureSignal( Actor* actor, const GestureDetectorContainer& gestureDetectors, Vector2 actorCoordinates ) override;
private:
/**
* Virtual destructor.
*/
- virtual ~TapGestureRecognizer();
+ ~TapGestureRecognizer() override;
public:
/**
* @copydoc Dali::Internal::GestureDetector::SendEvent(const Integration::TouchEvent&)
*/
- virtual void SendEvent(const Integration::TouchEvent& event);
+ void SendEvent(const Integration::TouchEvent& event) override;
/**
* @copydoc Dali::Internal::GestureDetector::Update(const Integration::GestureRequest&)
*/
- virtual void Update(const GestureRequest& request);
+ void Update(const GestureRequest& request) override;
private:
{
class TouchEvent;
-typedef IntrusivePtr< TouchEvent > TouchEventPtr;
+using TouchEventPtr = IntrusivePtr<TouchEvent>;
/**
* @copydoc Dali::TouchEvent
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TouchEvent() = default;
+ ~TouchEvent() override = default;
private:
}
else
{
- mLastConsumedActor.SetActor( NULL );
+ mLastConsumedActor.SetActor( nullptr );
}
mLastRenderTask = currentRenderTask;
AllocAndEmitTouchSignals( event.time, touchDownConsumedActorHandle, currentPoint );
}
- mTouchDownConsumedActor.SetActor( NULL );
+ mTouchDownConsumedActor.SetActor( nullptr );
DALI_FALLTHROUGH;
}
// Do not set mLastPrimaryHitActor to NULL we may be iterating through its observers
- mLastConsumedActor.SetActor( NULL );
+ mLastConsumedActor.SetActor( nullptr );
mLastRenderTask.Reset();
}
}
{
class WheelEvent;
-typedef IntrusivePtr< WheelEvent > WheelEventPtr;
+using WheelEventPtr = IntrusivePtr<WheelEvent>;
/**
* @copydoc Dali::WheelEvent
*
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~WheelEvent() = default;
+ ~WheelEvent() override = default;
// Not copyable or movable
{
class BitmapCompressed;
-typedef IntrusivePtr<BitmapCompressed> BitmapCompressedPtr;
+using BitmapCompressedPtr = IntrusivePtr<BitmapCompressed>;
/**
* BitmapCompressed class.
*/
BitmapCompressed( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN );
- virtual const Bitmap::CompressedProfile* GetCompressedProfile() const { return this; }
- virtual Bitmap::CompressedProfile* GetCompressedProfile() { return this; }
+ const Bitmap::CompressedProfile* GetCompressedProfile() const override { return this; }
+ Bitmap::CompressedProfile* GetCompressedProfile() override { return this; }
private:
/**
* @param[in] bufferSize Buffer size in bytes
* @return pixel buffer pointer
*/
- virtual Dali::Integration::PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
+ Dali::Integration::PixelBuffer* ReserveBufferOfSize( Pixel::Format pixelFormat,
const uint32_t width,
const uint32_t height,
- const uint32_t numBytes );
+ const uint32_t numBytes ) override;
/**
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
*/
- virtual uint32_t GetBufferSize() const
+ uint32_t GetBufferSize() const override
{
return mBufferSize;
}
/**
* See Dali::Integration::Bitmap::GetReleaseFunction()
*/
- ReleaseFunction GetReleaseFunction(){ return FREE; }
+ ReleaseFunction GetReleaseFunction() override{ return FREE; }
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~BitmapCompressed();
+ ~BitmapCompressed() override;
private:
if(HasAlphaChannel())
{
uint8_t* pixelBuffer=GetBuffer();
- if(pixelBuffer != NULL)
+ if(pixelBuffer != nullptr)
{
uint8_t* row = pixelBuffer;
{
class BitmapPackedPixel;
-typedef IntrusivePtr<BitmapPackedPixel> BitmapPackedPixelPtr;
+using BitmapPackedPixelPtr = IntrusivePtr<BitmapPackedPixel>;
/**
* BitmapPackedPixel class.
* Constructor
* @param[in] discardable Flag to tell the bitmap if it can delete the buffer with the pixel data.
*/
- BitmapPackedPixel( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = 0 );
+ BitmapPackedPixel( ResourcePolicy::Discardable discardable = ResourcePolicy::OWNED_RETAIN, Dali::Integration::PixelBuffer* pixBuf = nullptr );
public:
- virtual const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const { return this; }
- virtual Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() { return this; }
+ const Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() const override { return this; }
+ Bitmap::PackedPixelsProfile* GetPackedPixelsProfile() override { return this; }
/**
* (Re-)Allocate pixel buffer for the Bitmap. Any previously allocated pixel buffer is deleted.
* @param[in] bufferHeight Buffer height in pixels
* @return pixel buffer pointer
*/
- virtual Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
+ Dali::Integration::PixelBuffer* ReserveBuffer(Pixel::Format pixelFormat,
uint32_t width,
uint32_t height,
uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0);
+ uint32_t bufferHeight = 0) override;
/**
* Assign a pixel buffer. Any previously allocated pixel buffer is deleted.
* @param[in] bufferWidth Buffer width (stride) in pixels
* @param[in] bufferHeight Buffer height in pixels
*/
- virtual void AssignBuffer(Pixel::Format pixelFormat,
+ void AssignBuffer(Pixel::Format pixelFormat,
Dali::Integration::PixelBuffer* buffer,
uint32_t bufferSize,
uint32_t width,
uint32_t height,
uint32_t bufferWidth = 0,
- uint32_t bufferHeight = 0);
+ uint32_t bufferHeight = 0) override;
/**
* Get the width of the buffer (stride)
* @return The width of the buffer in pixels
*/
- virtual unsigned GetBufferWidth() const
+ unsigned GetBufferWidth() const override
{
return mBufferWidth;
}
* Get the height of the buffer
* @return The height of the buffer in pixels
*/
- virtual unsigned GetBufferHeight() const
+ unsigned GetBufferHeight() const override
{
return mBufferHeight;
}
* Get the pixel buffer size in bytes
* @return The buffer size in bytes.
*/
- virtual uint32_t GetBufferSize() const
+ uint32_t GetBufferSize() const override
{
return mBufferWidth * mBytesPerPixel * mBufferHeight;
}
/**
* See Dali::Integration::Bitmap::GetReleaseFunction()
*/
- ReleaseFunction GetReleaseFunction(){ return FREE; }
+ ReleaseFunction GetReleaseFunction() override{ return FREE; }
/**
* Get the pixel buffer stride.
* @return The buffer stride (in bytes).
*/
- virtual uint32_t GetBufferStride() const;
+ uint32_t GetBufferStride() const override;
/**
* Get the pixel format
* Check the bitmap data and test whether it has any transparent pixels.
* This property can then be tested for with IsFullyOpaque().
*/
- virtual void TestForTransparency();
+ void TestForTransparency() override;
protected:
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~BitmapPackedPixel();
+ ~BitmapPackedPixel() override;
protected:
DevelPixelData::PixelDataBuffer PixelData::ReleaseBuffer()
{
DevelPixelData::PixelDataBuffer pixelDataBuffer(mBuffer, mBufferSize, mReleaseFunction);
- mBuffer = NULL;
+ mBuffer = nullptr;
return pixelDataBuffer;
}
{
class PixelData;
-typedef IntrusivePtr<PixelData> PixelDataPtr;
+using PixelDataPtr = IntrusivePtr<PixelData>;
class PixelData : public BaseObject
{
*
* Release the pixel buffer if exists.
*/
- ~PixelData();
+ ~PixelData() override;
public:
*
*/
+// EXTERNAL INCLUDES
+#include <string_view>
+
// INTERNAL INCLUDES
#include <dali/public-api/object/property.h>
*/
struct PropertyDetails
{
- const char* name; ///< The name of the property.
+ std::string_view name; ///< The name of the property.
Property::Index enumIndex; ///< Used to check the index is correct within a debug build.
Property::Type type; ///< The property type.
bool writable; ///< Whether the property is writable
struct DefaultPropertyMetadata
{
const PropertyDetails* propertyTable; ///< address of the table defining property meta-data.
- Property::Index propertyCount; ///< count of the default properties.
+ const Property::Index propertyCount; ///< count of the default properties.
};
+inline constexpr bool CheckPropertyMetadata(const DefaultPropertyMetadata& table, Property::Index startIndex) noexcept
+{
+ for(int i = 0; i < table.propertyCount; i++)
+ {
+ if(table.propertyTable[i].enumIndex != startIndex + i)
+ return false;
+ }
+ return true;
+}
+
+template<size_t N>
+inline constexpr DefaultPropertyMetadata GeneratePropertyMetadata(const PropertyDetails (&array)[N]) noexcept
+{
+ return {array, N};
+}
+
} // namespace Dali
#endif // DALI_DEFAULT_PROPERTY_METADATA_H
const char* const SIGNAL_FINISHED = "finished";
-TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), NULL, RenderTaskDefaultProperties );
+TypeRegistration mType( typeid( Dali::RenderTask ), typeid( Dali::BaseHandle ), nullptr, RenderTaskDefaultProperties );
SignalConnectorType signalConnector1( mType, SIGNAL_FINISHED, &RenderTask::DoConnectSignal );
void RenderTask::SetFrameBuffer( FrameBufferPtr frameBuffer )
{
mFrameBuffer = frameBuffer;
- Render::FrameBuffer* renderFrameBufferPtr( NULL );
+ Render::FrameBuffer* renderFrameBufferPtr( nullptr );
if( frameBuffer )
{
renderFrameBufferPtr = mFrameBuffer->GetRenderObject();
const SceneGraph::PropertyBase* RenderTask::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
- const SceneGraph::PropertyBase* property( NULL );
+ const SceneGraph::PropertyBase* property( nullptr );
switch ( index )
{
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
public: //signals
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RenderTask();
+ ~RenderTask() override;
private: // not copyable
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~RenderTaskList();
+ ~RenderTaskList() override;
/**
* 2nd-phase construction
/**
* @copydoc CompleteNotificationInterface::NotifyCompleted()
*/
- virtual void NotifyCompleted();
+ void NotifyCompleted() override;
private:
FrameBuffer::FrameBuffer( uint32_t width, uint32_t height, Mask attachments )
: mEventThreadServices( EventThreadServices::Get() ),
- mRenderObject( NULL ),
+ mRenderObject( nullptr ),
mColor{ nullptr },
mDepth( nullptr ),
mStencil( nullptr ),
}
class FrameBuffer;
-typedef IntrusivePtr<FrameBuffer> FrameBufferPtr;
+using FrameBufferPtr = IntrusivePtr<FrameBuffer>;
class FrameBuffer : public BaseObject
{
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~FrameBuffer();
+ ~FrameBuffer() override;
/**
* @brief Get the FrameBuffer render object
Geometry::Geometry()
: mEventThreadServices( EventThreadServices::Get() ),
- mRenderObject( NULL ),
+ mRenderObject( nullptr ),
mType(Dali::Geometry::TRIANGLES)
{
}
}
class Geometry;
-typedef IntrusivePtr<Geometry> GeometryPtr;
+using GeometryPtr = IntrusivePtr<Geometry>;
/**
* Geometry is an object that contains an array of structures of values that
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Geometry();
+ ~Geometry() override;
private: // unimplemented methods
Geometry( const Geometry& );
const SceneGraph::PropertyBase* Renderer::GetSceneObjectAnimatableProperty( Property::Index index ) const
{
- const SceneGraph::PropertyBase* property = NULL;
+ const SceneGraph::PropertyBase* property = nullptr;
if( index == DevelRenderer::Property::OPACITY )
{
}
class Renderer;
-typedef IntrusivePtr<Renderer> RendererPtr;
+using RendererPtr = IntrusivePtr<Renderer>;
/**
* Renderer is an object that can be used to show content by combining a Geometry with a shader and textures.
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::OnNotifyDefaultPropertyAnimation()
*/
- virtual void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType );
+ void OnNotifyDefaultPropertyAnimation( Animation& animation, Property::Index index, const Property::Value& value, Animation::Type animationType ) override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectAnimatableProperty()
*/
- virtual const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const;
+ const SceneGraph::PropertyBase* GetSceneObjectAnimatableProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetSceneObjectInputProperty()
*/
- virtual const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const;
+ const PropertyInputImpl* GetSceneObjectInputProperty( Property::Index index ) const override;
/**
* @brief Adds a draw command to the Renderer.
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Renderer();
+ ~Renderer() override;
private: // unimplemented methods
Renderer( const Renderer& );
void Sampler::SetFilterMode( Dali::FilterMode::Type minFilter, Dali::FilterMode::Type magFilter )
{
- if( NULL != mRenderObject )
+ if( nullptr != mRenderObject )
{
SetFilterModeMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, static_cast< unsigned int >( minFilter ), static_cast< unsigned int >( magFilter ) );
}
void Sampler::SetWrapMode( Dali::WrapMode::Type rWrap, Dali::WrapMode::Type sWrap, Dali::WrapMode::Type tWrap )
{
- if( NULL != mRenderObject )
+ if( nullptr != mRenderObject )
{
SetWrapModeMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, static_cast< unsigned int >( rWrap ), static_cast< unsigned int >( sWrap ), static_cast< unsigned int >( tWrap ) );
}
Sampler::Sampler()
:mEventThreadServices( EventThreadServices::Get() ),
- mRenderObject( NULL )
+ mRenderObject( nullptr )
{
}
}
class Sampler;
-typedef IntrusivePtr<Sampler> SamplerPtr;
+using SamplerPtr = IntrusivePtr<Sampler>;
/**
* Sampler is an object that contains an array of structures of values that
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Sampler();
+ ~Sampler() override;
private: // data
EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via the update thread
}
class Shader;
-typedef IntrusivePtr<Shader> ShaderPtr;
+using ShaderPtr = IntrusivePtr<Shader>;
/**
* Shader is an object that contains an array of structures of values that
/**
* @copydoc Dali::Internal::Object::SetDefaultProperty()
*/
- virtual void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue);
+ void SetDefaultProperty(Property::Index index, const Property::Value& propertyValue) override;
/**
* @copydoc Dali::Internal::Object::GetDefaultProperty()
*/
- virtual Property::Value GetDefaultProperty( Property::Index index ) const;
+ Property::Value GetDefaultProperty( Property::Index index ) const override;
/**
* @copydoc Dali::Internal::Object::GetDefaultPropertyCurrentValue()
*/
- virtual Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const;
+ Property::Value GetDefaultPropertyCurrentValue( Property::Index index ) const override;
private: // implementation
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Shader();
+ ~Shader() override;
private: // unimplemented methods
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/internal/event/rendering/texture-impl.h> // Dali::Internal::Texture
// INTERNAL INCLUDES
-#include <dali/internal/update/manager/update-manager.h>
-#include <dali/internal/event/common/stage-impl.h>
#include <dali/integration-api/render-controller.h>
+#include <dali/internal/event/common/stage-impl.h>
+#include <dali/internal/update/manager/update-manager.h>
+
+// EXTERNAL INCLUDES
+#include <cstring>
+
+namespace
+{
+const char* DEFAULT_SAMPLER_TYPENAME = "sampler2D";
+} // namespace
namespace Dali
{
namespace Internal
{
-
-TexturePtr Texture::New(TextureType::Type type, Pixel::Format format, unsigned int width, unsigned int height )
+TexturePtr Texture::New(TextureType::Type type, Pixel::Format format, unsigned int width, unsigned int height)
{
- constexpr auto max_value = std::numeric_limits< uint16_t >::max();
- DALI_ASSERT_ALWAYS( ( width < max_value )&&( height < max_value )&& "Size out of range" );
- TexturePtr texture( new Texture( type, format, ImageDimensions( width, height) ) );
+ constexpr auto max_value = std::numeric_limits<uint16_t>::max();
+ DALI_ASSERT_ALWAYS((width < max_value) && (height < max_value) && "Size out of range");
+ TexturePtr texture(new Texture(type, format, ImageDimensions(width, height)));
texture->Initialize();
return texture;
}
-TexturePtr Texture::New( NativeImageInterface& nativeImageInterface )
+TexturePtr Texture::New(NativeImageInterface& nativeImageInterface)
{
- TexturePtr texture( new Texture( &nativeImageInterface ) );
+ TexturePtr texture(new Texture(&nativeImageInterface));
texture->Initialize();
// Request event processing and update forcely.
- texture->mEventThreadServices.GetRenderController().RequestProcessEventsOnIdle( true );
+ texture->mEventThreadServices.GetRenderController().RequestProcessEventsOnIdle(true);
texture->mEventThreadServices.ForceNextUpdate();
return texture;
}
return mRenderObject;
}
-Texture::Texture(TextureType::Type type, Pixel::Format format, ImageDimensions size )
-: mEventThreadServices( EventThreadServices::Get() ),
- mRenderObject( NULL ),
+Texture::Texture(TextureType::Type type, Pixel::Format format, ImageDimensions size)
+: mEventThreadServices(EventThreadServices::Get()),
+ mRenderObject(nullptr),
mNativeImage(),
- mSize( size ),
- mType( type ),
- mFormat( format )
+ mSize(size),
+ mType(type),
+ mFormat(format)
{
}
-Texture::Texture( NativeImageInterfacePtr nativeImageInterface )
-: mEventThreadServices( EventThreadServices::Get() ),
- mRenderObject( NULL ),
- mNativeImage( nativeImageInterface ),
- mSize( nativeImageInterface->GetWidth(), nativeImageInterface->GetHeight() ),
- mType( TextureType::TEXTURE_2D ),
- mFormat( Pixel::RGB888 )
+Texture::Texture(NativeImageInterfacePtr nativeImageInterface)
+: mEventThreadServices(EventThreadServices::Get()),
+ mRenderObject(nullptr),
+ mNativeImage(nativeImageInterface),
+ mSize(nativeImageInterface->GetWidth(), nativeImageInterface->GetHeight()),
+ mType(TextureType::TEXTURE_2D),
+ mFormat(Pixel::RGB888)
{
}
void Texture::Initialize()
{
- if( EventThreadServices::IsCoreRunning() )
+ if(EventThreadServices::IsCoreRunning())
{
- if( mNativeImage )
+ if(mNativeImage)
{
- mRenderObject = new Render::Texture( mNativeImage );
+ mRenderObject = new Render::Texture(mNativeImage);
}
else
{
- mRenderObject = new Render::Texture( mType, mFormat, mSize );
+ mRenderObject = new Render::Texture(mType, mFormat, mSize);
}
- OwnerPointer< Render::Texture > transferOwnership( mRenderObject );
- AddTexture( mEventThreadServices.GetUpdateManager(), transferOwnership );
+ OwnerPointer<Render::Texture> transferOwnership(mRenderObject);
+ AddTexture(mEventThreadServices.GetUpdateManager(), transferOwnership);
}
}
Texture::~Texture()
{
- if( EventThreadServices::IsCoreRunning() && mRenderObject )
+ if(EventThreadServices::IsCoreRunning() && mRenderObject)
{
- RemoveTexture( mEventThreadServices.GetUpdateManager(), *mRenderObject );
+ RemoveTexture(mEventThreadServices.GetUpdateManager(), *mRenderObject);
}
}
-bool Texture::Upload( PixelDataPtr pixelData )
+bool Texture::Upload(PixelDataPtr pixelData)
{
- return Upload( pixelData, 0u, 0u, 0u, 0u, pixelData->GetWidth(), pixelData->GetHeight() );
+ return Upload(pixelData, 0u, 0u, 0u, 0u, pixelData->GetWidth(), pixelData->GetHeight());
}
-bool Texture::Upload( PixelDataPtr pixelData,
- unsigned int layer, unsigned int mipmap,
- unsigned int xOffset, unsigned int yOffset,
- unsigned int width, unsigned int height )
+bool Texture::Upload(PixelDataPtr pixelData,
+ unsigned int layer,
+ unsigned int mipmap,
+ unsigned int xOffset,
+ unsigned int yOffset,
+ unsigned int width,
+ unsigned int height)
{
- constexpr auto max_value = std::numeric_limits< uint16_t >::max();
- DALI_ASSERT_ALWAYS( layer < max_value &&
- mipmap < max_value &&
- xOffset < max_value &&
- yOffset < max_value &&
- width < max_value &&
- height < max_value &&
- "Parameter value out of range" );
+ constexpr auto max_value = std::numeric_limits<uint16_t>::max();
+ DALI_ASSERT_ALWAYS(layer < max_value &&
+ mipmap < max_value &&
+ xOffset < max_value &&
+ yOffset < max_value &&
+ width < max_value &&
+ height < max_value &&
+ "Parameter value out of range");
bool result(false);
- if( EventThreadServices::IsCoreRunning() && mRenderObject )
+ if(EventThreadServices::IsCoreRunning() && mRenderObject)
{
- if( mNativeImage )
+ if(mNativeImage)
{
- DALI_LOG_ERROR( "OpenGL ES does not support uploading data to native texture\n");
+ DALI_LOG_ERROR("OpenGL ES does not support uploading data to native texture\n");
}
else
{
- unsigned int pixelDataSize = pixelData->GetWidth()*pixelData->GetHeight();
- if( pixelData->GetBuffer() == NULL || pixelDataSize == 0 )
+ unsigned int pixelDataSize = pixelData->GetWidth() * pixelData->GetHeight();
+ if(pixelData->GetBuffer() == nullptr || pixelDataSize == 0)
{
- DALI_LOG_ERROR( "PixelData is empty\n");
+ DALI_LOG_ERROR("PixelData is empty\n");
}
else
{
Pixel::Format pixelDataFormat = pixelData->GetPixelFormat();
- if( ( pixelDataFormat == mFormat ) || ( (pixelDataFormat == Pixel::RGB888 ) && ( mFormat == Pixel::RGBA8888 ) ) )
+ if((pixelDataFormat == mFormat) || ((pixelDataFormat == Pixel::RGB888) && (mFormat == Pixel::RGBA8888)))
{
- if( pixelDataSize < width * height )
+ if(pixelDataSize < width * height)
{
- DALI_LOG_ERROR( "PixelData of an incorrect size when trying to update texture\n");
+ DALI_LOG_ERROR("PixelData of an incorrect size when trying to update texture\n");
}
- else if( ( xOffset + width > ( mSize.GetWidth() / (1u << mipmap) ) ) ||
- ( yOffset + height > ( mSize.GetHeight() / (1u << mipmap) ) ) )
+ else if((xOffset + width > (mSize.GetWidth() / (1u << mipmap))) ||
+ (yOffset + height > (mSize.GetHeight() / (1u << mipmap))))
{
- DALI_LOG_ERROR( "Texture update area out of bounds\n");
+ DALI_LOG_ERROR("Texture update area out of bounds\n");
}
else
{
//Parameters are correct. Send message to upload data to the texture
- UploadParams params = { static_cast< uint16_t >( layer ),
- static_cast< uint16_t >( mipmap ),
- static_cast< uint16_t >( xOffset ),
- static_cast< uint16_t >( yOffset ),
- static_cast< uint16_t >( width ),
- static_cast< uint16_t >( height ) };
- UploadTextureMessage( mEventThreadServices.GetUpdateManager(), *mRenderObject, pixelData, params );
+ UploadParams params = {static_cast<uint16_t>(layer),
+ static_cast<uint16_t>(mipmap),
+ static_cast<uint16_t>(xOffset),
+ static_cast<uint16_t>(yOffset),
+ static_cast<uint16_t>(width),
+ static_cast<uint16_t>(height)};
+ UploadTextureMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject, pixelData, params);
// Request event processing and update forcely
- mEventThreadServices.GetRenderController().RequestProcessEventsOnIdle( true );
+ mEventThreadServices.GetRenderController().RequestProcessEventsOnIdle(true);
mEventThreadServices.ForceNextUpdate();
result = true;
}
else
{
- DALI_LOG_ERROR( "Bad format\n");
+ DALI_LOG_ERROR("Bad format\n");
}
}
}
void Texture::GenerateMipmaps()
{
- if( EventThreadServices::IsCoreRunning() && mRenderObject )
+ if(EventThreadServices::IsCoreRunning() && mRenderObject)
{
- GenerateMipmapsMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject );
+ GenerateMipmapsMessage(mEventThreadServices.GetUpdateManager(), *mRenderObject);
}
}
return mSize.GetHeight();
}
+bool Texture::IsNative() const
+{
+ return mNativeImage != nullptr;
+}
+
+bool Texture::ApplyNativeFragmentShader(std::string& shader)
+{
+ std::string fragmentShader;
+ bool modified = false;
+ if(mNativeImage != nullptr && !shader.empty())
+ {
+ const char* fragmentPrefix = mNativeImage->GetCustomFragmentPrefix();
+ const char* customSamplerTypename = mNativeImage->GetCustomSamplerTypename();
+
+ if(fragmentPrefix != nullptr)
+ {
+ modified = true;
+ fragmentShader = fragmentPrefix;
+ fragmentShader += "\n";
+ }
+ fragmentShader += shader;
+
+ if(customSamplerTypename != nullptr)
+ {
+ modified = true;
+ size_t pos = fragmentShader.find(DEFAULT_SAMPLER_TYPENAME);
+ if(pos < fragmentShader.length())
+ {
+ fragmentShader.replace(pos, strlen(DEFAULT_SAMPLER_TYPENAME), customSamplerTypename);
+ }
+ }
+ }
+
+ if(modified)
+ {
+ shader = fragmentShader;
+ }
+
+ return modified;
+}
+
} // namespace Internal
} // namespace Dali
#define DALI_INTERNAL_NEW_TEXTURE_H
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
-#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
-#include <dali/public-api/object/base-object.h>
-#include <dali/public-api/images/pixel.h>
-#include <dali/public-api/images/image-operations.h> // Dali::ImageDimensions
-#include <dali/public-api/rendering/texture.h> // Dali::Internal::Render::Texture
#include <dali/internal/event/common/event-thread-services.h>
#include <dali/internal/event/images/pixel-data-impl.h>
+#include <dali/public-api/common/dali-common.h> // DALI_ASSERT_ALWAYS
+#include <dali/public-api/common/intrusive-ptr.h> // Dali::IntrusivePtr
+#include <dali/public-api/images/image-operations.h> // Dali::ImageDimensions
+#include <dali/public-api/images/pixel.h>
+#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/rendering/texture.h> // Dali::Internal::Render::Texture
namespace Dali
{
}
class Texture;
-typedef IntrusivePtr<Texture> TexturePtr;
+using TexturePtr = IntrusivePtr<Texture>;
class Texture : public BaseObject
{
public:
-
/**
* @brief Structure used to pass parameters to the Upload method
*/
struct UploadParams
{
- uint16_t layer; ///< Specifies the layer of a cube map or array texture
- uint16_t mipmap; ///< Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image.
- uint16_t xOffset; ///< Specifies a texel offset in the x direction within the texture array.
- uint16_t yOffset; ///< Specifies a texel offset in the y direction within the texture array.
- uint16_t width; ///< Specifies the width of the texture subimage
- uint16_t height; ///< Specifies the height of the texture subimage.
+ uint16_t layer; ///< Specifies the layer of a cube map or array texture
+ uint16_t mipmap; ///< Specifies the level-of-detail number. Level 0 is the base image level. Level n is the nth mipmap reduction image.
+ uint16_t xOffset; ///< Specifies a texel offset in the x direction within the texture array.
+ uint16_t yOffset; ///< Specifies a texel offset in the y direction within the texture array.
+ uint16_t width; ///< Specifies the width of the texture subimage
+ uint16_t height; ///< Specifies the height of the texture subimage.
};
/**
* @param[in] nativeImageInterface The native image
* @return A smart-pointer to the newly allocated Texture.
*/
- static TexturePtr New( NativeImageInterface& nativeImageInterface );
+ static TexturePtr New(NativeImageInterface& nativeImageInterface);
/**
* @brief Get the texture render object
/**
* @copydoc Dali::Texture::Upload()
*/
- bool Upload( PixelDataPtr pixelData );
+ bool Upload(PixelDataPtr pixelData);
/**
* @copydoc Dali::Texture::Upload()
*/
- bool Upload( PixelDataPtr pixelData,
- unsigned int layer, unsigned int mipmap,
- unsigned int xOffset, unsigned int yOffset,
- unsigned int width, unsigned int height );
+ bool Upload(PixelDataPtr pixelData,
+ unsigned int layer,
+ unsigned int mipmap,
+ unsigned int xOffset,
+ unsigned int yOffset,
+ unsigned int width,
+ unsigned int height);
/**
* @copydoc Dali::Texture::GenerateMipmaps()
*/
unsigned int GetHeight() const;
-private: // implementation
+ /**
+ * @brief Determine if the texture is a native image
+ *
+ * @return true if the texture has been initialized with a native image
+ */
+ bool IsNative() const;
+
+ /**
+ * @brief Apply any native texture code to the given fragment shader
+ *
+ * @param[in,out] shader The fragment shader
+ * @return true if the shader has been modified.
+ */
+ bool ApplyNativeFragmentShader(std::string& shader);
+private: // implementation
/**
* Constructor
* @param[in] type The type of the texture
* @param[in] format The format of the pixel data
* @param[in] size The size of the texture
*/
- Texture(TextureType::Type type, Pixel::Format format, ImageDimensions size );
+ Texture(TextureType::Type type, Pixel::Format format, ImageDimensions size);
/**
* Constructor from native image
* @param[in] nativeImageInterface The native image
*/
- Texture( NativeImageInterfacePtr nativeImageInterface );
+ Texture(NativeImageInterfacePtr nativeImageInterface);
/**
* Second stage initialization of the Texture
void Initialize();
protected:
-
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~Texture();
+ ~Texture() override;
private: // unimplemented methods
- Texture( const Texture& );
- Texture& operator=( const Texture& );
+ Texture(const Texture&);
+ Texture& operator=(const Texture&);
-private: // data
-
- Internal::EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via update thread
- Internal::Render::Texture* mRenderObject; ///<The Render::Texture associated to this texture
+private: // data
+ Internal::EventThreadServices& mEventThreadServices; ///<Used to send messages to the render thread via update thread
+ Internal::Render::Texture* mRenderObject; ///<The Render::Texture associated to this texture
NativeImageInterfacePtr mNativeImage; ///< Pointer to native image
- ImageDimensions mSize; ///< Size of the texture
+ ImageDimensions mSize; ///< Size of the texture
Dali::TextureType::Type mType; ///< Texture type (cached)
- Pixel::Format mFormat; ///< Pixel format
-
+ Pixel::Format mFormat; ///< Pixel format
};
} // namespace Internal
for( uint32_t i(textureCount); i<=index; ++i )
{
- mTextures[i] = NULL;
+ mTextures[i] = nullptr;
if( !samplerExist )
{
- mSamplers[i] = NULL;
+ mSamplers[i] = nullptr;
}
}
}
mTextures[index]= texture;
- Render::Texture* renderTexture(0);
+ Render::Texture* renderTexture(nullptr);
if( texture )
{
renderTexture = texture->GetRenderObject();
Texture* TextureSet::GetTexture( uint32_t index ) const
{
- Texture* result(0);
+ Texture* result(nullptr);
if( index < mTextures.size() )
{
result = mTextures[index].Get();
mSamplers.resize( index + 1 );
for( uint32_t i = samplerCount; i<=index; ++i )
{
- mSamplers[i] = NULL;
+ mSamplers[i] = nullptr;
}
}
mSamplers[index] = sampler;
- Render::Sampler* renderSampler(0);
+ Render::Sampler* renderSampler(nullptr);
if( sampler )
{
renderSampler = sampler->GetSamplerRenderObject();
Sampler* TextureSet::GetSampler( uint32_t index ) const
{
- Sampler* result(0);
+ Sampler* result(nullptr);
if( index < mSamplers.size() )
{
result = mSamplers[index].Get();
TextureSet::TextureSet()
:mEventThreadServices( EventThreadServices::Get() ),
- mSceneObject( NULL )
+ mSceneObject( nullptr )
{
}
class TextureSet;
-typedef IntrusivePtr<TextureSet> TextureSetPtr;
+using TextureSetPtr = IntrusivePtr<TextureSet>;
/**
* TextureSet is an object that holds all the textures used by a renderer
/**
* A reference counted object may only be deleted by calling Unreference()
*/
- virtual ~TextureSet();
+ ~TextureSet() override;
private: // unimplemented methods
TextureSet( const TextureSet& );
VertexBuffer::VertexBuffer()
: mEventThreadServices( EventThreadServices::Get() ),
- mRenderObject( NULL ),
+ mRenderObject( nullptr ),
mBufferFormatSize( 0 ),
mSize( 0 )
{
{
class VertexBuffer;
-typedef IntrusivePtr<VertexBuffer> VertexBufferPtr;
+using VertexBufferPtr = IntrusivePtr<VertexBuffer>;
/**
* VertexBuffer is an object that contains an array of structures of values that
/**
* @brief Destructor
*/
- ~VertexBuffer();
+ ~VertexBuffer() override;
private: // implementation
/**
{
// typedef ... Type; not defined, only support types declared below
};
-template<> struct PropertyImplementationType< Property::BOOLEAN > { typedef bool Type; };
-template<> struct PropertyImplementationType< Property::FLOAT > { typedef float Type; };
-template<> struct PropertyImplementationType< Property::INTEGER > { typedef int Type; };
-template<> struct PropertyImplementationType< Property::VECTOR2 > { typedef Vector2 Type; };
-template<> struct PropertyImplementationType< Property::VECTOR3 > { typedef Vector3 Type; };
-template<> struct PropertyImplementationType< Property::VECTOR4 > { typedef Vector4 Type; };
-template<> struct PropertyImplementationType< Property::MATRIX3 > { typedef Matrix3 Type; };
-template<> struct PropertyImplementationType< Property::MATRIX > { typedef Matrix Type; };
-template<> struct PropertyImplementationType< Property::RECTANGLE > { typedef Rect<int> Type; };
-template<> struct PropertyImplementationType< Property::ROTATION > { typedef Quaternion Type; };
+template<>
+struct PropertyImplementationType<Property::BOOLEAN>
+{
+ using Type = bool;
+};
+template<>
+struct PropertyImplementationType<Property::FLOAT>
+{
+ using Type = float;
+};
+template<>
+struct PropertyImplementationType<Property::INTEGER>
+{
+ using Type = int;
+};
+template<>
+struct PropertyImplementationType<Property::VECTOR2>
+{
+ using Type = Vector2;
+};
+template<>
+struct PropertyImplementationType<Property::VECTOR3>
+{
+ using Type = Vector3;
+};
+template<>
+struct PropertyImplementationType<Property::VECTOR4>
+{
+ using Type = Vector4;
+};
+template<>
+struct PropertyImplementationType<Property::MATRIX3>
+{
+ using Type = Matrix3;
+};
+template<>
+struct PropertyImplementationType<Property::MATRIX>
+{
+ using Type = Matrix;
+};
+template<>
+struct PropertyImplementationType<Property::RECTANGLE>
+{
+ using Type = Rect<int>;
+};
+template<>
+struct PropertyImplementationType<Property::ROTATION>
+{
+ using Type = Quaternion;
+};
uint32_t GetPropertyImplementationSize( Property::Type& propertyType );
/**
* Virtual destructor
*/
- virtual ~MemoryPoolRelayoutContainer();
+ ~MemoryPoolRelayoutContainer() override;
/**
* @brief Add relayout information to the container if it does'nt already exist
* @param actor The actor to relayout
* @param size The size to relayout
*/
- virtual void Add( const Dali::Actor& actor, const Vector2& size );
+ void Add( const Dali::Actor& actor, const Vector2& size ) override;
/**
* @brief Remove information from the container
bool Contains( const Dali::Actor& actor );
private:
-
- typedef Vector< RelayoutInfo* > RelayoutInfoContainer;
+ using RelayoutInfoContainer = Vector<RelayoutInfo*>;
RelayoutInfoContainer mRelayoutInfos; ///< The list of relayout infos
/**
* Destructor
*/
- virtual ~RelayoutController();
+ ~RelayoutController() override;
/**
* @brief Get the singleton of RelayoutController object.
SET( internal_src_files
${internal_src_dir}/common/blending-options.cpp
${internal_src_dir}/common/core-impl.cpp
- ${internal_src_dir}/common/internal-constants.cpp
${internal_src_dir}/common/math.cpp
${internal_src_dir}/common/message-buffer.cpp
${internal_src_dir}/common/mutex-trace.cpp
${internal_src_dir}/common/fixed-size-memory-pool.cpp
${internal_src_dir}/event/actors/actor-impl.cpp
+ ${internal_src_dir}/event/actors/actor-property-handler.cpp
+ ${internal_src_dir}/event/actors/actor-relayouter.cpp
${internal_src_dir}/event/actors/custom-actor-internal.cpp
${internal_src_dir}/event/actors/layer-impl.cpp
${internal_src_dir}/event/actors/layer-list.cpp
${internal_src_dir}/event/events/pinch-gesture/pinch-gesture-event.cpp
${internal_src_dir}/event/events/pinch-gesture/pinch-gesture-processor.cpp
${internal_src_dir}/event/events/pinch-gesture/pinch-gesture-recognizer.cpp
+ ${internal_src_dir}/event/events/ray-test.cpp
${internal_src_dir}/event/events/rotation-gesture/rotation-gesture-detector-impl.cpp
${internal_src_dir}/event/events/rotation-gesture/rotation-gesture-processor.cpp
${internal_src_dir}/event/events/rotation-gesture/rotation-gesture-recognizer.cpp
{
RenderInstruction::RenderInstruction()
-: mRenderTracker( NULL ),
+: mRenderTracker( nullptr ),
mClearColor(),
mIsViewportSet( false ),
mIsClearColorSet( false ),
mIgnoreRenderToFbo( false ),
- mFrameBuffer( 0 ),
- mCamera( 0 ),
+ mFrameBuffer( nullptr ),
+ mCamera( nullptr ),
mNextFreeRenderList( 0 )
{
// reserve 6 lists, which is enough for three layers with opaque and transparent things on
// Return null if the caller has passed an invalid index:
if( index >= std::min( mNextFreeRenderList, mRenderLists.Size() ) )
{
- return 0;
+ return nullptr;
}
return mRenderLists[ index ];
{
mCamera = camera;
mViewport = viewport ? *viewport : Viewport();
- mIsViewportSet = NULL != viewport;
+ mIsViewportSet = nullptr != viewport;
mClearColor = clearColor ? *clearColor : Color::BLACK;
- mIsClearColorSet = NULL != clearColor;
- mRenderTracker = NULL;
+ mIsClearColorSet = nullptr != clearColor;
+ mRenderTracker = nullptr;
mNextFreeRenderList = 0;
mFrameBuffer = frameBuffer;
mModelViewMatrix( false ),
mColor( Vector4::ZERO ),
mSize(),
- mRenderer( NULL ),
- mNode( NULL ),
- mTextureSet( NULL ),
+ mRenderer( nullptr ),
+ mNode( nullptr ),
+ mTextureSet( nullptr ),
mDepthIndex( 0 ),
mIsOpaque( true ),
mIsUpdated( false )
namespace Dali
{
-
-typedef Rect<int> ClippingBox;
+using ClippingBox = Rect<int>;
namespace Internal
{
class Layer;
-typedef OwnerContainer< RenderItem* > RenderItemContainer;
+using RenderItemContainer = OwnerContainer<RenderItem*>;
struct RenderList;
-typedef OwnerContainer< RenderList* > RenderListContainer;
+using RenderListContainer = OwnerContainer<RenderList*>;
/**
* The RenderList structure provides the renderer with a list of renderers.
*/
RenderList()
: mNextFree( 0 ),
- mClippingBox( NULL ),
- mSourceLayer( NULL ),
+ mClippingBox( nullptr ),
+ mSourceLayer( nullptr ),
mHasColorRenderItems( false )
{
}
mNextFree = 0;
delete mClippingBox;
- mClippingBox = NULL;
+ mClippingBox = nullptr;
}
/**
*/
bool IsClipping() const
{
- return ( NULL != mClippingBox );
+ return ( nullptr != mClippingBox );
}
/**
}
RenderManager::RenderManager()
-: mImpl(NULL)
+: mImpl(nullptr)
{
}
clearMask |= GL_STENCIL_BUFFER_BIT;
}
- if( !instruction.mIgnoreRenderToFbo && ( instruction.mFrameBuffer != 0 ) )
+ if( !instruction.mIgnoreRenderToFbo && ( instruction.mFrameBuffer != nullptr ) )
{
// Offscreen buffer rendering
if ( instruction.mIsViewportSet )
}
bool clearFullFrameRect = true;
- if( instruction.mFrameBuffer != 0 )
+ if( instruction.mFrameBuffer != nullptr )
{
Viewport frameRect( 0, 0, instruction.mFrameBuffer->GetWidth(), instruction.mFrameBuffer->GetHeight() );
clearFullFrameRect = ( frameRect == viewportRect );
{
RenderTracker::RenderTracker()
-: mGlSyncAbstraction( NULL ),
- mSyncObject( NULL ),
+: mGlSyncAbstraction( nullptr ),
+ mSyncObject( nullptr ),
mSyncTrigger( 0 )
{
TRACKER_LOG(Debug::Verbose);
if( mSyncObject )
{
mGlSyncAbstraction->DestroySyncObject( mSyncObject );
- mSyncObject = NULL;
+ mSyncObject = nullptr;
}
}
if( mSyncObject )
{
mGlSyncAbstraction->DestroySyncObject( mSyncObject );
- mSyncObject = NULL;
+ mSyncObject = nullptr;
}
ResetSyncFlag();
mSyncObject = mGlSyncAbstraction->CreateSyncObject();
{
SetSyncFlag();
mGlSyncAbstraction->DestroySyncObject( mSyncObject );
- mSyncObject = NULL;
+ mSyncObject = nullptr;
TRACKER_LOG_FMT(Debug::General, " Synced\n");
return;
/**
* @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMapChanged()
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const = 0;
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override = 0;
/**
* @copydoc Dali::Internal::SceneGraph::UniformMapDataProvider::GetUniformMap()
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const = 0;
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override = 0;
protected:
/**
* Virtual destructor, this is an interface, no deletion through this interface
*/
- virtual ~NodeDataProvider() { }
+ ~NodeDataProvider() override { }
};
} // SceneGraph
{
RenderDataProvider::RenderDataProvider( AnimatableProperty< float >& opacity )
-: mUniformMapDataProvider( NULL ),
- mShader( NULL ),
+: mUniformMapDataProvider( nullptr ),
+ mShader( nullptr ),
mOpacity( opacity )
{
}
class RenderDataProvider
{
public:
- typedef std::vector< Render::Sampler* > Samplers;
+ using Samplers = std::vector<Render::Sampler*>;
/**
* Constructor.
class UniformMap;
class UniformPropertyMapping;
-typedef Dali::Vector< const UniformPropertyMapping* > CollectedUniformMap;
+using CollectedUniformMap = Dali::Vector<const UniformPropertyMapping*>;
/**
* This class maps uniform names to property value pointers.
* Size of the VertexAttributeArray enables
* GLES specification states that there's minimum of 8
*/
- static const unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 8;
+ static constexpr unsigned int MAX_ATTRIBUTE_CACHE_SIZE = 8;
- static const unsigned int MAX_TEXTURE_UNITS = 8; // for GLES 2.0 8 is guaranteed, which is more than DALi uses anyways
+ static constexpr unsigned int MAX_TEXTURE_UNITS = 8; // for GLES 2.0 8 is guaranteed, which is more than DALi uses anyways
+ static constexpr unsigned int MAX_TEXTURE_TARGET = 3; // We support only GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP and GL_TEXTURE_EXTERNAL_OES now
/**
* Creates the Dali Context object for surface rendering only.
DALI_LOG_INFO(Debug::Filter::gRender, Debug::General, "GL %s = %s\n", stringName, reinterpret_cast< const char * >( GetString( stringId ) ) );
}
+ /**
+ * Reset the cached buffer ids.
+ */
void ResetBufferCache()
{
// reset the cached buffer id's
mBoundTransformFeedbackBufferId = 0;
}
+ /**
+ * Reset the cached texture ids.
+ */
void ResetTextureCache()
{
// reset the cached texture id's in case the driver re-uses them
// when creating new textures
- for( unsigned int i=0; i < MAX_TEXTURE_UNITS; ++i )
+ for(unsigned int i = 0; i < MAX_TEXTURE_UNITS; ++i)
{
- mBoundTextureId[ i ] = 0;
+ for(unsigned int j = 0; j < MAX_TEXTURE_TARGET; ++j)
+ {
+ mBoundTextureId[i][j] = 0;
+ }
+ }
+ }
+
+ /**
+ * Get an index of the cached texture list from the texture target.
+ * @param target The texture target
+ * @return The index of the cached texture list
+ */
+ static constexpr int16_t GetTextureIndexFromGlFormat(int target)
+ {
+ switch(target)
+ {
+ case GL_TEXTURE_2D:
+ {
+ return 0;
+ }
+ case GL_TEXTURE_CUBE_MAP:
+ {
+ return 1;
+ }
+ case GL_TEXTURE_EXTERNAL_OES:
+ {
+ return 2;
+ }
+ default:
+ {
+ return -1;
+ }
}
}
*/
void BindTextureForUnit( TextureUnit textureunit, int target, GLuint texture )
{
- if( mBoundTextureId[ textureunit ] != texture )
- {
- ActiveTexture( textureunit );
- BindTexture( target, texture );
- }
+ ActiveTexture(textureunit);
+ BindTexture(target, texture);
}
/**
*/
void BindTexture( int target, GLuint texture )
{
- if (mBoundTextureId[ mActiveTextureUnit ] != texture)
+ int16_t index = GetTextureIndexFromGlFormat(target);
+ if(index >= 0 && mBoundTextureId[ mActiveTextureUnit ][index] != texture)
{
- mBoundTextureId[ mActiveTextureUnit ] = texture;
+ mBoundTextureId[ mActiveTextureUnit ][index] = texture;
LOG_GL("BindTexture target(%d) %d\n", target, texture);
- CHECK_GL( mGlAbstraction, mGlAbstraction.BindTexture(target, texture) );
+ CHECK_GL(mGlAbstraction, mGlAbstraction.BindTexture(target, texture));
}
}
// glBindTexture() state
TextureUnit mActiveTextureUnit;
- GLuint mBoundTextureId[ MAX_TEXTURE_UNITS ]; ///< The ID passed to glBindTexture()
+ GLuint mBoundTextureId[ MAX_TEXTURE_UNITS ][MAX_TEXTURE_TARGET]; ///< The ID passed to glBindTexture()
// glBlendColor() state
Vector4 mBlendColor; ///< Blend color
return &state;
}
}
- return NULL;
+ return nullptr;
}
void FrameBufferStateCache::DeleteFrameBuffer( GLuint frameBufferId )
unsigned int mState; ///< State, bitmask of FrameBufferStatus flags
};
- typedef Dali::Vector< FrameBufferState > FrameBufferStateVector;
+ using FrameBufferStateVector = Dali::Vector<FrameBufferState>;
/**
* @brief Set the clear state
{
RenderQueue::RenderQueue()
-: container0( NULL ),
- container1( NULL )
+: container0( nullptr ),
+ container1( nullptr )
{
container0 = new MessageBuffer( INITIAL_BUFFER_SIZE );
container1 = new MessageBuffer( INITIAL_BUFFER_SIZE );
MessageBuffer* RenderQueue::GetCurrentContainer( BufferIndex bufferIndex )
{
- MessageBuffer* container( NULL );
+ MessageBuffer* container( nullptr );
/**
* The update-thread queues messages with one container,
if( MAX_BUFFER_SIZE < container0->GetCapacity() )
{
delete container0;
- container0 = NULL;
+ container0 = nullptr;
container0 = new MessageBuffer( INITIAL_BUFFER_SIZE );
}
}
if( MAX_BUFFER_SIZE < container1->GetCapacity() )
{
delete container1;
- container1 = NULL;
+ container1 = nullptr;
container1 = new MessageBuffer( INITIAL_BUFFER_SIZE );
}
}
Geometry::Geometry()
: mIndices(),
- mIndexBuffer(NULL),
+ mIndexBuffer(nullptr),
mGeometryType( Dali::Geometry::TRIANGLES ),
mIndicesChanged(false),
mHasBeenUpdated(false),
{
if( mIndices.Empty() )
{
- mIndexBuffer = NULL;
+ mIndexBuffer = nullptr;
}
else
{
- if ( mIndexBuffer == NULL )
+ if ( mIndexBuffer == nullptr )
{
mIndexBuffer = new GpuBuffer( context );
}
class Geometry
{
public:
- typedef Dali::Geometry::Type Type;
+ using Type = Dali::Geometry::Type;
Geometry();
DepthFunction::Type depthFunction,
StencilParameters& stencilParameters )
: mRenderDataProvider( dataProvider ),
- mContext( NULL),
+ mContext( nullptr),
mGeometry( geometry ),
mUniformIndexMap(),
mAttributesLocation(),
return true;
}
- std::vector<Render::Texture*> textures = mRenderDataProvider->GetTextures();
- for (Render::Texture* texture : textures)
+ for( const auto& texture : mRenderDataProvider->GetTextures() )
{
if (texture && texture->IsNativeImage())
{
/**
* @copydoc Dali::Internal::GlResourceOwner::GlContextDestroyed()
*/
- void GlContextDestroyed();
+ void GlContextDestroyed() override;
/**
* @copydoc Dali::Internal::GlResourceOwner::GlCleanup()
*/
- void GlCleanup();
+ void GlCleanup() override;
/**
* Create a new renderer instance
/**
* Destructor
*/
- ~Renderer();
+ ~Renderer() override;
/**
* Set the face-culling mode.
const PropertyInputImpl* propertyValue;
};
- typedef Dali::Vector< UniformIndexMap > UniformIndexMappings;
+ using UniformIndexMappings = Dali::Vector<UniformIndexMap>;
UniformIndexMappings mUniformIndexMap;
Vector<GLint> mAttributesLocation;
struct Sampler
{
-
- typedef Dali::FilterMode::Type FilterMode;
- typedef Dali::WrapMode::Type WrapMode;
+ using FilterMode = Dali::FilterMode::Type;
+ using WrapMode = Dali::WrapMode::Type;
/**
* Constructor
{
if( !mIsCompressed )
{
- context.TexImage2D(GL_TEXTURE_2D, 0, mGlInternalFormat, mWidth, mHeight, 0, mGlFormat, mPixelDataType, 0 );
+ context.TexImage2D(GL_TEXTURE_2D, 0, mGlInternalFormat, mWidth, mHeight, 0, mGlFormat, mPixelDataType, nullptr );
}
else
{
- context.CompressedTexImage2D(GL_TEXTURE_2D, 0, mGlInternalFormat, mWidth, mHeight, 0, 0, 0 );
+ context.CompressedTexImage2D(GL_TEXTURE_2D, 0, mGlInternalFormat, mWidth, mHeight, 0, 0, nullptr );
}
}
else if( mType == TextureType::TEXTURE_CUBE )
{
for( uint32_t i(0); i<6; ++i )
{
- context.TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, mGlInternalFormat, mWidth, mHeight, 0, mGlFormat, mPixelDataType, 0 );
+ context.TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, mGlInternalFormat, mWidth, mHeight, 0, mGlFormat, mPixelDataType, nullptr );
}
}
else
{
for( uint32_t i(0); i<6; ++i )
{
- context.CompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, mGlInternalFormat, mWidth, mHeight, 0, 0, 0 );
+ context.CompressedTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, mGlInternalFormat, mWidth, mHeight, 0, 0, nullptr );
}
}
context.TexParameteri( mTarget, GL_TEXTURE_WRAP_R, GL_WRAP_DEFAULT );
void Texture::Upload( Context& context, PixelDataPtr pixelData, const Internal::Texture::UploadParams& params )
{
- DALI_ASSERT_ALWAYS( mNativeImage == NULL );
+ DALI_ASSERT_ALWAYS( mNativeImage == nullptr );
//Get pointer to the data of the PixelData object
uint8_t* buffer( pixelData->GetBuffer() );
class Texture
{
public:
-
- typedef Dali::TextureType::Type Type;
+ using Type = Dali::TextureType::Type;
/**
* Constructor
{
VertexBuffer::VertexBuffer()
-:mFormat(NULL),
- mData(NULL),
- mGpuBuffer(NULL),
+:mFormat(nullptr),
+ mData(nullptr),
+ mGpuBuffer(nullptr),
mSize(0),
mDataChanged(true)
{
{
ProgramController::ProgramController( Integration::GlAbstraction& glAbstraction )
-: mShaderSaver( 0 ),
+: mShaderSaver( nullptr ),
mGlAbstraction( glAbstraction ),
- mCurrentProgram( NULL ),
+ mCurrentProgram( nullptr ),
mProgramBinaryFormat( 0 ),
mNumberOfProgramBinaryFormats( 0 )
{
for ( ProgramIterator iter = mProgramCache.Begin(); iter != end; ++iter )
{
Program* program = (*iter)->GetProgram();
- program->SetProjectionMatrix( NULL );
- program->SetViewMatrix( NULL );
+ program->SetProjectionMatrix( nullptr );
+ program->SetViewMatrix( nullptr );
}
}
mNumberOfProgramBinaryFormats = 0;
mProgramBinaryFormat = 0;
- SetCurrentProgram( NULL );
+ SetCurrentProgram( nullptr );
// Inform programs they are no longer valid
const ProgramIterator end = mProgramCache.End();
for ( ProgramIterator iter = mProgramCache.Begin(); iter != end; ++iter )
Program* ProgramController::GetProgram( size_t shaderHash )
{
- Program* program = NULL;
+ Program* program = nullptr;
const ProgramIterator end = mProgramCache.End();
for ( ProgramIterator iter = mProgramCache.Begin(); iter != end; ++iter )
{
DALI_ASSERT_DEBUG( programData->GetBufferSize() > 0 );
DALI_ASSERT_DEBUG( mShaderSaver && "SetShaderSaver() should have been called during startup." );
- if( mShaderSaver != NULL )
+ if( mShaderSaver != nullptr )
{
mShaderSaver->SaveBinary( programData );
}
/**
* Destructor, non virtual as not a base class
*/
- ~ProgramController();
+ ~ProgramController() override;
public: // API
/**
* @copydoc ProgramCache::GetGlAbstraction
*/
- virtual Integration::GlAbstraction& GetGlAbstraction();
+ Integration::GlAbstraction& GetGlAbstraction() override;
/**
* @copydoc ProgramCache::GetProgram
*/
- virtual Program* GetProgram( size_t shaderHash );
+ Program* GetProgram( size_t shaderHash ) override;
/**
* @copydoc ProgramCache::AddProgram
*/
- virtual void AddProgram( size_t shaderHash, Program* program );
+ void AddProgram( size_t shaderHash, Program* program ) override;
/**
* @copydoc ProgramCache::GetCurrentProgram
*/
- virtual Program* GetCurrentProgram();
+ Program* GetCurrentProgram() override;
/**
* @copydoc ProgramCache::SetCurrentProgram
*/
- virtual void SetCurrentProgram( Program* program );
+ void SetCurrentProgram( Program* program ) override;
/**
* @copydoc ProgramCache::IsBinarySupported
*/
- virtual bool IsBinarySupported();
+ bool IsBinarySupported() override;
/**
* @copydoc ProgramCache::ProgramBinaryFormat
*/
- virtual GLenum ProgramBinaryFormat();
+ GLenum ProgramBinaryFormat() override;
/**
* @copydoc ProgramCache::StoreBinary
*/
- virtual void StoreBinary( Internal::ShaderDataPtr programData );
+ void StoreBinary( Internal::ShaderDataPtr programData ) override;
private: // not implemented as non-copyable
Integration::GlAbstraction& mGlAbstraction;
Program* mCurrentProgram;
- typedef OwnerContainer< ProgramPair* > ProgramContainer;
- typedef ProgramContainer::Iterator ProgramIterator;
+ using ProgramContainer = OwnerContainer<ProgramPair*>;
+ using ProgramIterator = ProgramContainer::Iterator;
ProgramContainer mProgramCache;
GLint mProgramBinaryFormat;
size_t shaderHash = shaderData->GetHashValue();
Program* program = cache.GetProgram( shaderHash );
- if( NULL == program )
+ if( nullptr == program )
{
// program not found so create it
program = new Program( cache, shaderData, modifiesGeometry );
{
char* outerToken = strtok_r( uniform + UNIFORM.mLength, ";", &uniform );
- char* nextPtr = NULL;
+ char* nextPtr = nullptr;
char* token = strtok_r( outerToken, DELIMITERS, &nextPtr );
while ( token )
{
if ( std::find(SAMPLER_TYPES, END_SAMPLER_TYPES, token) != END_SAMPLER_TYPES )
{
bool found( false );
- token = strtok_r( NULL, DELIMITERS, &nextPtr );
+ token = strtok_r( nullptr, DELIMITERS, &nextPtr );
for (uint32_t i=0; i < static_cast<uint32_t>( samplerUniformLocations.size() ); ++i)
{
if ( samplerUniformLocations[i].position == -1 &&
}
}
- token = strtok_r( NULL, DELIMITERS, &nextPtr );
+ token = strtok_r( nullptr, DELIMITERS, &nextPtr );
}
uniform = strstr( uniform, UNIFORM );
Program::Program( ProgramCache& cache, Internal::ShaderDataPtr shaderData, bool modifiesGeometry )
: mCache( cache ),
mGlAbstraction( mCache.GetGlAbstraction() ),
- mProjectionMatrix( NULL ),
- mViewMatrix( NULL ),
+ mProjectionMatrix( nullptr ),
+ mViewMatrix( nullptr ),
mLinked( false ),
mVertexShaderId( 0 ),
mFragmentShaderId( 0 ),
void Program::Load()
{
- DALI_ASSERT_ALWAYS( NULL != mProgramData.Get() && "Program data is not initialized" );
+ DALI_ASSERT_ALWAYS( nullptr != mProgramData.Get() && "Program data is not initialized" );
DALI_ASSERT_DEBUG( mProgramId == 0 && "mProgramId != 0, so about to leak a GL resource by overwriting it." );
LOG_GL( "CreateProgram()\n" );
// Allocate space for the bytecode in ShaderData
mProgramData->AllocateBuffer(binaryLength);
// Copy the bytecode to ShaderData
- CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramBinary(mProgramId, binaryLength, NULL, &binaryFormat, mProgramData->GetBufferData()) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.GetProgramBinary(mProgramId, binaryLength, nullptr, &binaryFormat, mProgramData->GetBufferData()) );
mCache.StoreBinary( mProgramData );
DALI_LOG_INFO( Debug::Filter::gShader, Debug::General, "Saved binary.\n" );
}
{
CHECK_GL( mGlAbstraction, mGlAbstraction.UseProgram(0) );
- mCache.SetCurrentProgram( NULL );
+ mCache.SetCurrentProgram( nullptr );
}
if (mProgramId)
}
LOG_GL( "ShaderSource(%d)\n", shaderId );
- CHECK_GL( mGlAbstraction, mGlAbstraction.ShaderSource(shaderId, 1, &src, NULL ) );
+ CHECK_GL( mGlAbstraction, mGlAbstraction.ShaderSource(shaderId, 1, &src, nullptr ) );
LOG_GL( "CompileShader(%d)\n", shaderId );
CHECK_GL( mGlAbstraction, mGlAbstraction.CompileShader( shaderId ) );
Internal::ShaderDataPtr mProgramData; ///< Shader program source and binary (when compiled & linked or loaded)
// location caches
- typedef std::pair< std::string, GLint > NameLocationPair;
- typedef std::vector< NameLocationPair > Locations;
+ using NameLocationPair = std::pair<std::string, GLint>;
+ using Locations = std::vector<NameLocationPair>;
Locations mAttributeLocations; ///< attribute location cache
Locations mUniformLocations; ///< uniform location cache
Shader::Shader( Dali::Shader::Hint::Value& hints )
: mHints( hints ),
- mProgram( NULL ),
+ mProgram( nullptr ),
mConnectionObservers()
{
AddUniformMapObserver( *this );
/**
* Virtual destructor
*/
- virtual ~Shader();
+ ~Shader() override;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// The following methods are called during Update
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
*/
- virtual void UniformMappingsChanged( const UniformMap& mappings );
+ void UniformMappingsChanged( const UniformMap& mappings ) override;
private: // Data
/**
* Virtual destructor.
*/
- virtual ~AnimatorBase()
+ ~AnimatorBase() override
{
delete mAnimatorFunction;
if (mPropertyOwner && mConnectedToSceneGraph)
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner )
*/
- void PropertyOwnerConnected( PropertyOwner& owner ) override final
+ void PropertyOwnerConnected( PropertyOwner& owner ) final
{
mEnabled = true;
}
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
*/
- void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override final
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) final
{
// If we are active, then bake the value if required
if ( mAnimationPlaying && mDisconnectAction != Dali::Animation::DISCARD )
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner )
*/
- void PropertyOwnerDestroyed( PropertyOwner& owner ) override final
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) final
{
mPropertyOwner = nullptr;
}
{
mConnectedToSceneGraph = true;
mPropertyOwner->AddObserver(*this);
+
+ // Enable if the target object is valid and connected to the scene graph.
+ mEnabled = mPropertyOwner->IsAnimationPossible();
}
/**
/**
* Virtual destructor.
*/
- virtual ~Animator()
+ ~Animator() override
{
}
/**
* @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final
+ void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) final
{
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
/**
* Virtual destructor.
*/
- virtual ~AnimatorTransformProperty()
+ ~AnimatorTransformProperty() override
{
}
/**
* @copydoc AnimatorBase::DoUpdate( BufferIndex bufferIndex, bool bake, float alpha )
*/
- virtual void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) override final
+ void DoUpdate( BufferIndex bufferIndex, bool bake, float alpha ) final
{
const PropertyType& current = mPropertyAccessor.Get( bufferIndex );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const int32_t& property)
+ float operator()(float alpha, const int32_t& property) override
{
// integers need to be correctly rounded
return roundf(static_cast<float>( property ) + static_cast<float>( mRelative ) * alpha );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const int32_t& property)
+ float operator()(float alpha, const int32_t& property) override
{
// integers need to be correctly rounded
return roundf(static_cast<float>( property ) + (static_cast<float>(mTarget - property) * alpha) );
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const float& property)
+ float operator()(float alpha, const float& property) override
{
return float(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- float operator()(float alpha, const float& property)
+ float operator()(float alpha, const float& property) override
{
return float(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float alpha, const Vector2& property)
+ Vector2 operator()(float alpha, const Vector2& property) override
{
return Vector2(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float alpha, const Vector2& property)
+ Vector2 operator()(float alpha, const Vector2& property) override
{
return Vector2(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float alpha, const Vector3& property)
+ Vector3 operator()(float alpha, const Vector3& property) override
{
return Vector3(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float alpha, const Vector3& property)
+ Vector3 operator()(float alpha, const Vector3& property) override
{
return Vector3(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
return Vector4(property + mRelative * alpha);
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
return Vector4(property + ((mTarget - property) * alpha));
}
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
Vector4 result(property);
result.a += mRelative * alpha;
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float alpha, const Vector4& property)
+ Vector4 operator()(float alpha, const Vector4& property) override
{
Vector4 result(property);
result.a = property.a + ((mTarget - property.a) * alpha);
}
using AnimatorFunctionBase::operator();
- bool operator()(float alpha, const bool& property)
+ bool operator()(float alpha, const bool& property) override
{
// Alpha is not useful here, just keeping to the same template as other update functors
return bool(alpha >= 1.0f ? (property || mRelative) : property);
}
using AnimatorFunctionBase::operator();
- bool operator()(float alpha, const bool& property)
+ bool operator()(float alpha, const bool& property) override
{
// Alpha is not useful here, just keeping to the same template as other update functors
return bool(alpha >= 1.0f ? mTarget : property);
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float alpha, const Quaternion& rotation)
+ Quaternion operator()(float alpha, const Quaternion& rotation) override
{
if (alpha > 0.0f)
{
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float alpha, const Quaternion& rotation)
+ Quaternion operator()(float alpha, const Quaternion& rotation) override
{
return Quaternion::Slerp(rotation, mTarget, alpha);
}
}
using AnimatorFunctionBase::operator();
- bool operator()(float progress, const bool& property)
+ bool operator()(float progress, const bool& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- float operator()(float progress, const int32_t& property)
+ float operator()(float progress, const int32_t& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- float operator()(float progress, const float& property)
+ float operator()(float progress, const float& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector2 operator()(float progress, const Vector2& property)
+ Vector2 operator()(float progress, const Vector2& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float progress, const Vector3& property)
+ Vector3 operator()(float progress, const Vector3& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector4 operator()(float progress, const Vector4& property)
+ Vector4 operator()(float progress, const Vector4& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float progress, const Quaternion& property)
+ Quaternion operator()(float progress, const Quaternion& property) override
{
if(mKeyFrames->IsActive(progress))
{
}
using AnimatorFunctionBase::operator();
- Vector3 operator()(float progress, const Vector3& property)
+ Vector3 operator()(float progress, const Vector3& property) override
{
Vector3 position(property);
static_cast<void>( mPath->SamplePosition(progress, position) );
}
using AnimatorFunctionBase::operator();
- Quaternion operator()(float progress, const Quaternion& property)
+ Quaternion operator()(float progress, const Quaternion& property) override
{
Vector3 tangent;
if( mPath->SampleTangent(progress, tangent) )
namespace SceneGraph
{
-
-typedef Dali::Vector<PropertyOwner*> PropertyOwnerContainer;
-typedef PropertyOwnerContainer::Iterator PropertyOwnerIter;
+using PropertyOwnerContainer = Dali::Vector<PropertyOwner*>;
+using PropertyOwnerIter = PropertyOwnerContainer::Iterator;
/**
* An abstract base class for Constraints.
};
public:
-
- typedef Dali::Constraint::RemoveAction RemoveAction;
+ using RemoveAction = Dali::Constraint::RemoveAction;
/**
* Constructor
/**
* Virtual destructor.
*/
- virtual ~ConstraintBase();
+ ~ConstraintBase() override;
/**
* Property resetter observes the lifecycle of this object
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected()
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner )
+ void PropertyOwnerConnected( PropertyOwner& owner ) override
{
}
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*/
- virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner )
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
{
if ( !mDisconnected )
{
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed()
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner )
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override
{
if ( !mDisconnected )
{
inline void SetRemoveActionMessage( EventThreadServices& eventThreadServices, const ConstraintBase& constraint, Dali::Constraint::RemoveAction removeAction )
{
- typedef MessageValue1< ConstraintBase, Dali::Constraint::RemoveAction > LocalType;
+ using LocalType = MessageValue1<ConstraintBase, Dali::Constraint::RemoveAction>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class ConstraintBase;
-typedef OwnerContainer< ConstraintBase* > ConstraintOwnerContainer;
-typedef ConstraintOwnerContainer::Iterator ConstraintIter;
+using ConstraintOwnerContainer = OwnerContainer<ConstraintBase *>;
+using ConstraintIter = ConstraintOwnerContainer::Iterator;
} // namespace SceneGraph
/**
* Virtual destructor.
*/
- virtual ~Constraint()
+ ~Constraint() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::ConstraintBase::Apply()
*/
- virtual void Apply( BufferIndex updateBufferIndex )
+ void Apply( BufferIndex updateBufferIndex ) override
{
if ( !mDisconnected )
{
/**
* @copydoc Dali::Internal::SceneGraph::ConstraintBase::OnDisconnect()
*/
- virtual void OnDisconnect()
+ void OnDisconnect() override
{
// Discard target object/property pointers
mTargetProperty.Reset();
/**
* Virtual destructor.
*/
- virtual ~AnimatablePropertyBase()
+ ~AnimatablePropertyBase() override
{}
protected: // for derived classes
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::IsClean()
*/
- virtual bool IsClean() const
+ bool IsClean() const override
{
return ( CLEAN_FLAG == mDirtyFlags );
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true; // Animatable properties are always valid
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<bool>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetBoolean()
*/
- virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
+ const bool& GetBoolean( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<int>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetInteger()
*/
- virtual const int& GetInteger( BufferIndex bufferIndex ) const
+ const int& GetInteger( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<float>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetFloat()
*/
- virtual const float& GetFloat( BufferIndex bufferIndex ) const
+ const float& GetFloat( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector2>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
+ const Vector2& GetVector2( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector4>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetVector4( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* Virtual destructor.
*/
- virtual ~AnimatableProperty()
+ ~AnimatableProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix3>();
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex)
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override
{
if (CLEAN_FLAG != mDirtyFlags)
{
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix3()
*/
- virtual const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const
+ const Matrix3& GetMatrix3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< T >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, T > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, T>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
const T& delta )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, const T& > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, const T&>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const SceneGraph::AnimatableProperty<T>& property,
typename ParameterType< float >::PassingType newValue )
{
- typedef MessageDoubleBuffered1< SceneGraph::AnimatableProperty<T>, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<SceneGraph::AnimatableProperty<T>, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
class DiscardQueue
{
public:
-
- typedef OwnerContainer< Shader* > ShaderQueue;
- typedef OwnerContainer< Renderer* > RendererQueue;
- typedef OwnerContainer< Camera* > CameraQueue;
- typedef OwnerContainer< Scene* > SceneQueue;
+ using ShaderQueue = OwnerContainer<Shader*>;
+ using RendererQueue = OwnerContainer<Renderer*>;
+ using CameraQueue = OwnerContainer<Camera*>;
+ using SceneQueue = OwnerContainer<Scene*>;
/**
* Create a new DiscardQueue.
/**
* Virtual destructor.
*/
- virtual ~InheritedVector3()
+ ~InheritedVector3() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector3()
*/
- virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedColor()
+ ~InheritedColor() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector4>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetVector4()
*/
- virtual const Vector4& GetVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetVector4( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector4()
*/
- virtual const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const
+ const Vector4& GetConstraintInputVector4( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedQuaternion()
+ ~InheritedQuaternion() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
*/
- virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~InheritedMatrix()
+ ~InheritedMatrix() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return mInheritedFlag;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
return mValue[ bufferIndex ];
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::GetConstraintInputMatrix()
*/
- virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const override
{
// For inherited properties, constraints work with the value from the previous frame.
// This is because constraints are applied to position etc, before world-position is calculated.
/**
* Virtual destructor.
*/
- virtual ~PropertyBase();
+ ~PropertyBase() override;
/**
* Reset the property to a base value; only required if the property is animated.
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return !IsClean();
}
ConditionFunction LessThan::GetFunction(Property::Type valueType)
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
switch(valueType)
{
ConditionFunction GreaterThan::GetFunction(Property::Type valueType)
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
switch(valueType)
{
ConditionFunction Inside::GetFunction(Property::Type valueType)
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
switch(valueType)
{
ConditionFunction Outside::GetFunction(Property::Type valueType)
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
switch(valueType)
{
ConditionFunction Step::GetFunction(Property::Type valueType)
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
switch(valueType)
{
ConditionFunction Step::GetCompareFunction( Property::Type valueType )
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
if( valueType == Property::VECTOR3 )
{
function = EvalAndCompareVector3;
ConditionFunction VariableStep::GetFunction( Property::Type valueType )
{
- ConditionFunction function = NULL;
+ ConditionFunction function = nullptr;
switch( valueType )
{
/**
* Virtual destructor
*/
- virtual ~PropertyOwnerMessageBase();
+ ~PropertyOwnerMessageBase() override;
private:
class AnimatablePropertyMessage : public PropertyOwnerMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~AnimatablePropertyMessage()
+ ~AnimatablePropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class AnimatablePropertyComponentMessage : public PropertyOwnerMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
/**
* Send a message.
/**
* Virtual destructor
*/
- virtual ~AnimatablePropertyComponentMessage()
+ ~AnimatablePropertyComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
inline void InstallCustomPropertyMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer<PropertyBase>& property )
{
- typedef MessageValue1< PropertyOwner, OwnerPointer<PropertyBase> > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, OwnerPointer<PropertyBase> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void ApplyConstraintMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer<ConstraintBase>& constraint )
{
- typedef MessageValue1< PropertyOwner, OwnerPointer<ConstraintBase> > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, OwnerPointer<ConstraintBase> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// The update-thread can modify this object.
ConstraintBase& constraint = const_cast< ConstraintBase& >( constConstraint );
- typedef MessageValue1< PropertyOwner, ConstraintBase* > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, ConstraintBase*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, OwnerPointer< UniformPropertyMapping >& map )
{
- typedef MessageValue1< PropertyOwner, OwnerPointer< UniformPropertyMapping > > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, OwnerPointer<UniformPropertyMapping> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveUniformMapMessage( EventThreadServices& eventThreadServices, const PropertyOwner& owner, const std::string& uniformName )
{
- typedef MessageValue1< PropertyOwner, std::string > LocalType;
+ using LocalType = MessageValue1<PropertyOwner, std::string>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
void PropertyOwner::ConnectToSceneGraph()
{
+ mIsConnectedToSceneGraph = true;
+
// Notification for observers
const ConstObserverIter endIter = mObservers.End();
for( ConstObserverIter iter = mObservers.Begin(); iter != endIter; ++iter)
void PropertyOwner::DisconnectFromSceneGraph( BufferIndex updateBufferIndex )
{
+ mIsConnectedToSceneGraph = false;
+
// Notification for observers
const ConstObserverIter endIter = mObservers.End();
for( ConstObserverIter iter = mObservers.Begin(); iter != endIter; ++iter)
}
PropertyOwner::PropertyOwner()
-: mUpdated( false )
+: mUpdated(false),
+ mIsConnectedToSceneGraph(false)
{
}
class PropertyOwner;
-typedef OwnerContainer< PropertyBase* > OwnedPropertyContainer;
-typedef OwnedPropertyContainer::Iterator OwnedPropertyIter;
+using OwnedPropertyContainer = OwnerContainer<PropertyBase*>;
+using OwnedPropertyIter = OwnedPropertyContainer::Iterator;
/**
* An update-thread object which own properties.
*/
void RemoveUniformMapObserver( UniformMap::Observer& observer );
+ /**
+ * Query whether playing an animation is possible or not.
+ * @return true if playing an animation is possible.
+ */
+ virtual bool IsAnimationPossible() const
+ {
+ return true;
+ }
protected:
OwnedPropertyContainer mCustomProperties; ///< Properties provided with InstallCustomProperty()
UniformMap mUniformMaps; ///< Container of owned uniform maps
bool mUpdated;
+ bool mIsConnectedToSceneGraph;
private:
-
- typedef Dali::Vector<PropertyOwner::Observer*> ObserverContainer;
- typedef ObserverContainer::Iterator ObserverIter;
- typedef ObserverContainer::ConstIterator ConstObserverIter;
+ using ObserverContainer = Dali::Vector<PropertyOwner::Observer*>;
+ using ObserverIter = ObserverContainer::Iterator;
+ using ConstObserverIter = ObserverContainer::ConstIterator;
ObserverContainer mObservers; ///< Container of observer raw-pointers (not owned)
/**
* Virtual Destructor
*/
- virtual ~PropertyResetterBase()
+ ~PropertyResetterBase() override
{
if( mPropertyOwner != nullptr )
{
*
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner ) override
+ void PropertyOwnerConnected( PropertyOwner& owner ) override
{
mDisconnected = false;
mActive = ACTIVE;
* @param[in] bufferIndex the current buffer index
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
+ void PropertyOwnerDisconnected( BufferIndex bufferIndex, PropertyOwner& owner ) override
{
mDisconnected = true;
}
* Called shortly before the propertyOwner is destroyed
* @param[in] owner The property owner
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner ) override
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override
{
mDisconnected = true;
mPropertyOwner = nullptr;
/**
* Virtual destructor.
*/
- virtual ~Resetter()
+ ~Resetter() override
{
// Disconnect from modifier object. Although this resetter should match the lifecycle of the modifier object,
// there are situations where it is deleted first (e.g. if the property owner is destroyed)
/**
* The Animator or Constraint is destroyed
*/
- virtual void ObjectDestroyed() override
+ void ObjectDestroyed() override
{
// When the modifier is destroyed, reduce the running value to ensure we stay alive for
// another frame to reset the other buffer.
ModifierType* mModifier;
};
-
-typedef Resetter<SceneGraph::AnimatorBase> AnimatorResetter;
-typedef Resetter<SceneGraph::ConstraintBase> ConstraintResetter;
-
-
+using AnimatorResetter = Resetter<SceneGraph::AnimatorBase>;
+using ConstraintResetter = Resetter<SceneGraph::ConstraintBase>;
} // namespace SceneGraph
void Destroy( PropertyOwner& object );
private:
- typedef Dali::Vector<Observer*> Observers;
- typedef Observers::Iterator ObserversIterator;
+ using Observers = Dali::Vector<Observer*>;
+ using ObserversIterator = Observers::Iterator;
Observers mObservers;
};
: mObject(&object),
mPropertyIndex(propertyIndex),
mPropertyType(propertyType),
- mProperty(NULL),
+ mProperty(nullptr),
mComponentIndex(componentIndex),
mConditionType(condition),
mArguments(arguments),
mValid(false),
mNotifyMode( Dali::PropertyNotification::DISABLED ),
- mConditionFunction(NULL)
+ mConditionFunction(nullptr)
{
SetNotifyMode(notifyMode);
class PropertyNotification;
-typedef OwnerContainer< PropertyNotification* > PropertyNotificationContainer;
-typedef PropertyNotificationContainer::Iterator PropertyNotificationIter;
-typedef PropertyNotificationContainer::ConstIterator PropertyNotificationConstIter;
-typedef bool(*ConditionFunction)(const Dali::PropertyInput& value, Dali::Internal::PropertyNotification::RawArgumentContainer& args);
+using PropertyNotificationContainer = OwnerContainer<PropertyNotification*>;
+using PropertyNotificationIter = PropertyNotificationContainer::Iterator;
+using PropertyNotificationConstIter = PropertyNotificationContainer::ConstIterator;
+using ConditionFunction = bool ( * )( const Dali::PropertyInput&, Dali::Internal::PropertyNotification::RawArgumentContainer& );
/**
* PropertyNotifications are used to inspect properties of scene graph objects, as part of a scene
class PropertyNotification
{
public:
-
- typedef Dali::PropertyNotification::NotifyMode NotifyMode;
- typedef Dali::Internal::PropertyNotification::ConditionType ConditionType;
- typedef Dali::Internal::PropertyNotification::RawArgumentContainer RawArgumentContainer;
- typedef const void *(*GetPropertyFunction)( const SceneGraph::PropertyBase*, int );
+ using NotifyMode = Dali::PropertyNotification::NotifyMode;
+ using ConditionType = Dali::Internal::PropertyNotification::ConditionType;
+ using RawArgumentContainer = Dali::Internal::PropertyNotification::RawArgumentContainer;
+ using GetPropertyFunction = const void* (*)( const SceneGraph::PropertyBase*, int );
/**
* Construct a new PropertyNotification
/// Messages
inline void AddFrameRenderedCallbackMessage( EventThreadServices& eventThreadServices, const Scene& scene, const CallbackBase* callback, int32_t frameId )
{
- typedef MessageValue2< Scene, CallbackBase*, int32_t > LocalType;
+ using LocalType = MessageValue2<Scene, CallbackBase*, int32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddFramePresentedCallbackMessage( EventThreadServices& eventThreadServices, const Scene& scene, const CallbackBase* callback, int32_t frameId )
{
- typedef MessageValue2< Scene, CallbackBase*, int32_t > LocalType;
+ using LocalType = MessageValue2<Scene, CallbackBase*, int32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
}
}
}
- return NULL;
+ return nullptr;
}
UniformMap::SizeType UniformMap::Count() const
class UniformPropertyMapping
{
public:
- typedef unsigned long Hash;
+ using Hash = unsigned long;
/**
* Constructor
*/
- UniformPropertyMapping( const std::string& theUniformName, const PropertyInputImpl* thePropertyPtr )
- : propertyPtr( thePropertyPtr ),
- uniformName( theUniformName ),
- uniformNameHash( Dali::CalculateHash( theUniformName ) )
+ UniformPropertyMapping(std::string theUniformName, const PropertyInputImpl* thePropertyPtr)
+ : propertyPtr(thePropertyPtr),
+ uniformName(std::move(theUniformName)),
+ uniformNameHash(Dali::CalculateHash(theUniformName))
{
}
UniformPropertyMapping()
- : propertyPtr( NULL ),
+ : propertyPtr( nullptr ),
uniformName( "" ),
uniformNameHash( 0 )
{
void MappingChanged();
private:
- typedef OwnerContainer< UniformPropertyMapping* > UniformMapContainer;
- typedef UniformMapContainer::Iterator UniformMapIter;
- typedef Dali::Vector< Observer* > Observers;
- typedef Observers::Iterator ObserversIter;
+ using UniformMapContainer = OwnerContainer<UniformPropertyMapping*>;
+ using UniformMapIter = UniformMapContainer::Iterator;
+ using Observers = Dali::Vector<Observer*>;
+ using ObserversIter = Observers::Iterator;
UniformMapContainer mUniformMaps; // Owner container of uniform maps
void RenderMessageDispatcher::RemoveRenderer( Render::Renderer& renderer )
{
- typedef MessageValue1< RenderManager, Render::Renderer* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Renderer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void RenderMessageDispatcher::AddRenderTracker( Render::RenderTracker& renderTracker )
{
- typedef MessageValue1< RenderManager, Render::RenderTracker* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::RenderTracker*>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void RenderMessageDispatcher::RemoveRenderTracker( Render::RenderTracker& renderTracker )
{
- typedef MessageValue1< RenderManager, Render::RenderTracker* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::RenderTracker*>;
// Reserve some memory inside the render queue
uint32_t* slot = mRenderQueue.ReserveMessageSlot( mBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
/**
* Destructor
*/
- virtual ~SceneControllerImpl();
+ ~SceneControllerImpl() override;
public: // from SceneController
/**
* @copydoc SceneController::GetRenderMessageDispatcher()
*/
- virtual RenderMessageDispatcher& GetRenderMessageDispatcher() { return mRenderMessageDispatcher; }
+ RenderMessageDispatcher& GetRenderMessageDispatcher() override { return mRenderMessageDispatcher; }
/**
* @copydoc SceneController::GetRenderQueue()
*/
- virtual RenderQueue& GetRenderQueue() { return mRenderQueue; }
+ RenderQueue& GetRenderQueue() override { return mRenderQueue; }
/**
* @copydoc SceneController::GetDiscardQueue()
*/
- virtual DiscardQueue& GetDiscardQueue() { return mDiscardQueue; }
+ DiscardQueue& GetDiscardQueue() override { return mDiscardQueue; }
private:
/**
* Virtual destructor.
*/
- virtual ~GestureProperty()
+ ~GestureProperty() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get< T >();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
// A constraint cannot use the property until it has been inherited (at least once).
return true;
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return mInputChanged;
}
/**
* Virtual destructor.
*/
- virtual ~GesturePropertyVector2()
+ ~GesturePropertyVector2() override
{
}
/**
* @copydoc Dali::PropertyInput::GetVector2()
*/
- virtual const Vector2& GetVector2( BufferIndex bufferIndex ) const
+ const Vector2& GetVector2( BufferIndex bufferIndex ) const override
{
return mValue;
}
/**
* Virtual destructor.
*/
- virtual ~GesturePropertyBool()
+ ~GesturePropertyBool() override
{
}
/**
* @copydoc Dali::PropertyInput::GetBoolean()
*/
- virtual const bool& GetBoolean( BufferIndex bufferIndex ) const
+ const bool& GetBoolean( BufferIndex bufferIndex ) const override
{
return mValue;
}
GestureState state;
};
- typedef std::vector< PanGestureProfiling::Position > PanPositionContainer;
+ using PanPositionContainer = std::vector<PanGestureProfiling::Position>;
void PrintData() const;
mInGesture( false ),
mPredictionAmountOverridden( false ),
mSmoothingAmountOverridden( false ),
- mProfiling( NULL ),
+ mProfiling( nullptr ),
// Set environment variable defaults:
mPredictionMode( DEFAULT_PREDICTION_MODE ),
volatile bool read;
};
- typedef std::vector<PanInfo> PanInfoHistory;
- typedef PanInfoHistory::iterator PanInfoHistoryIter;
- typedef PanInfoHistory::const_iterator PanInfoHistoryConstIter;
+ using PanInfoHistory = std::vector<PanInfo>;
+ using PanInfoHistoryIter = PanInfoHistory::iterator;
+ using PanInfoHistoryConstIter = PanInfoHistory::const_iterator;
private:
static const unsigned int PAN_GESTURE_HISTORY = 30u;
/**
* Virtual destructor
*/
- virtual ~PanGesture();
+ ~PanGesture() override;
/**
* Adds a PanGesture to the internal circular-buffer waiting to be handled by UpdateProperties.
// Struct to keep pairs of local and screen data together.
// TODO: This can encapsulate some functionality also.
- typedef struct
+ using RelativeVectors = struct
+
{
Vector2 local;
+
Vector2 screen;
- } RelativeVectors;
+ };
/**
* Houses new code to process input events and generate an output point.
Layer& layer = **iter;
const bool tryReuseRenderList( viewMatrixHasNotChanged && layer.CanReuseRenderers( &renderTask.GetCamera() ) );
const bool isLayer3D = layer.GetBehavior() == Dali::Layer::LAYER_3D;
- RenderList* renderList = NULL;
+ RenderList* renderList = nullptr;
if( layer.IsRoot() && ( layer.GetDirtyFlags() != NodePropertyFlags::NOTHING ) )
{
struct SortAttributes
{
SortAttributes()
- : renderItem( NULL ),
- shader( NULL ),
- textureSet( NULL ),
- geometry( NULL ),
+ : renderItem( nullptr ),
+ shader( nullptr ),
+ textureSet( nullptr ),
+ geometry( nullptr ),
zValue( 0.0f )
{
}
inline void SortRenderItems( BufferIndex bufferIndex, RenderList& renderList, Layer& layer, bool respectClippingOrder );
/// Sort comparitor function pointer type.
- typedef bool ( *ComparitorPointer )( const SortAttributes& lhs, const SortAttributes& rhs );
- typedef std::vector< SortAttributes > SortingHelper;
+ using ComparitorPointer = bool ( * )( const SortAttributes&, const SortAttributes& );
+
+ using SortingHelper = std::vector<SortAttributes>;
Dali::Vector< ComparitorPointer > mSortComparitors; ///< Contains all sort comparitors, used for quick look-up
RenderInstructionProcessor::SortingHelper mSortingHelper; ///< Helper used to sort Renderers
Layer* FindLayer( Node& node )
{
Node* currentNode( &node );
- Layer* layer( NULL );
+ Layer* layer( nullptr );
while( currentNode )
{
- if( ( layer = currentNode->GetLayer() ) != NULL )
+ if( ( layer = currentNode->GetLayer() ) != nullptr )
{
return layer;
}
currentNode = currentNode->GetParent();
}
- return NULL;
+ return nullptr;
}
/**
{
RenderTask& renderTask = **iter;
- const bool hasFrameBuffer = NULL != renderTask.GetFrameBuffer();
+ const bool hasFrameBuffer = nullptr != renderTask.GetFrameBuffer();
const bool isDefaultRenderTask = isFirstRenderTask;
isFirstRenderTask = false;
/**
* Non-virtual Destructor.
*/
- ~FrameCallback();
+ ~FrameCallback() override;
/**
* Called from the update-thread when connecting to the scene-graph.
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected()
*/
- virtual void PropertyOwnerConnected( PropertyOwner& owner ) { /* Nothing to do */ }
+ void PropertyOwnerConnected( PropertyOwner& owner ) override { /* Nothing to do */ }
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*/
- virtual void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) { /* Nothing to do */ }
+ void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) override { /* Nothing to do */ }
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected()
*
* Will use this to disconnect the frame-callback if the accompanying node is destroyed
*/
- virtual void PropertyOwnerDestroyed( PropertyOwner& owner );
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override;
// Construction
/**
* A container of Layer pointers sorted by depth
*/
-typedef std::vector<Layer*> SortedLayerPointers;
+using SortedLayerPointers = std::vector<Layer *>;
-typedef SortedLayerPointers::iterator SortedLayersIter;
-typedef SortedLayerPointers::const_iterator SortedLayersConstIter;
+using SortedLayersIter = SortedLayerPointers::iterator;
+using SortedLayersConstIter = SortedLayerPointers::const_iterator;
} // namespace SceneGraph
* Constructor
*/
TransformManagerPropertyHandler()
- :mTxManager(0),
+ :mTxManager(nullptr),
mId( INVALID_TRANSFORM_ID )
{}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const = 0;
+ Dali::Property::Type GetType() const override = 0;
/**
* @copydoc Dali::SceneGraph::AnimatableProperty::Get()
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const{ return Vector3::ZERO; }
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override{ return Vector3::ZERO; }
/**
* Retrieve a component of property
/**
* @copydoc Dali::AnimatableProperty::ResetToBaseValue()
*/
- virtual void ResetToBaseValue(BufferIndex updateBufferIndex){}
+ void ResetToBaseValue(BufferIndex updateBufferIndex) override{}
/**
* @copydoc Dali::AnimatableProperty::IsClean()
*/
- virtual bool IsClean() const{ return false; }
+ bool IsClean() const override{ return false; }
/**
* Initializes the property
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
mProperty( property )
{}
- Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
- Vector3& Get( BufferIndex bufferIndex )
+ Vector3& Get( BufferIndex bufferIndex ) override
{
return mTxManager->GetVector3PropertyValue( mId, mProperty );
}
- const Vector3& Get( BufferIndex bufferIndex ) const
+ const Vector3& Get( BufferIndex bufferIndex ) const override
{
return mTxManager->GetVector3PropertyValue( mId, mProperty );
}
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
return Get(bufferIndex);
}
- const float& GetFloatComponent( uint32_t component )
+ const float& GetFloatComponent( uint32_t component ) override
{
return mTxManager->GetVector3PropertyComponentValue( mId, mProperty, component );
}
- void Set(BufferIndex bufferIndex, const Vector3& value)
+ void Set(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->SetVector3PropertyValue( mId, mProperty, value );
}
mTxManager->BakeVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void Bake(BufferIndex bufferIndex, const Vector3& value)
+ void Bake(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeVector3PropertyValue(mId, mProperty, value );
}
- void BakeX(BufferIndex bufferIndex, float value)
+ void BakeX(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeXVector3PropertyValue(mId, mProperty, value );
}
- void BakeY(BufferIndex bufferIndex, float value)
+ void BakeY(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeYVector3PropertyValue(mId, mProperty, value );
}
- void BakeZ(BufferIndex bufferIndex, float value)
+ void BakeZ(BufferIndex bufferIndex, float value) override
{
mTxManager->BakeZVector3PropertyValue(mId, mProperty, value );
}
- void SetFloatComponent( float value, uint32_t component)
+ void SetFloatComponent( float value, uint32_t component) override
{
mTxManager->SetVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void BakeFloatComponent( float value, uint32_t component )
+ void BakeFloatComponent( float value, uint32_t component ) override
{
mTxManager->BakeVector3PropertyComponentValue( mId, mProperty, value, component);
}
- void BakeRelative(BufferIndex bufferIndex, const Vector3& value)
+ void BakeRelative(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeRelativeVector3PropertyValue(mId, mProperty, value );
}
- void BakeRelativeMultiply(BufferIndex bufferIndex, const Vector3& value)
+ void BakeRelativeMultiply(BufferIndex bufferIndex, const Vector3& value) override
{
mTxManager->BakeMultiplyVector3PropertyValue(mId, mProperty, value );
}
:TransformManagerPropertyHandler()
{}
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
- Quaternion& Get( BufferIndex bufferIndex )
+ Quaternion& Get( BufferIndex bufferIndex ) override
{
return mTxManager->GetQuaternionPropertyValue( mId );
}
- const Quaternion& Get( BufferIndex bufferIndex ) const
+ const Quaternion& Get( BufferIndex bufferIndex ) const override
{
return mTxManager->GetQuaternionPropertyValue( mId );
}
- const float& GetFloatComponent( uint32_t component)
+ const float& GetFloatComponent( uint32_t component) override
{
return mTxManager->GetQuaternionPropertyValue( mId ).mVector[component];
}
- void Set(BufferIndex bufferIndex, const Quaternion& value)
+ void Set(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->SetQuaternionPropertyValue( mId, value );
}
- void Bake(BufferIndex bufferIndex, const Quaternion& value)
+ void Bake(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->BakeQuaternionPropertyValue( mId, value );
}
- void BakeRelative(BufferIndex bufferIndex, const Quaternion& value)
+ void BakeRelative(BufferIndex bufferIndex, const Quaternion& value) override
{
return mTxManager->BakeRelativeQuaternionPropertyValue( mId, value );
}
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
return Get(bufferIndex);
}
* Create an TransformManagerVector3Input
*/
TransformManagerVector3Input( TransformManagerProperty property, const Vector3& initialValue )
- :mTxManager(0),
+ :mTxManager(nullptr),
mId(INVALID_TRANSFORM_ID),
mProperty(property),
mValue(initialValue)
/**
* Virtual destructor.
*/
- virtual ~TransformManagerVector3Input()
+ ~TransformManagerVector3Input() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Vector3>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetVector3()
*/
- virtual const Vector3& GetVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetVector3( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::PropertyInput::GetConstraintInputVector3()
*/
- virtual const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const
+ const Vector3& GetConstraintInputVector3( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
* Constructor
*/
TransformManagerQuaternionInput()
- :mTxManager(0),
+ :mTxManager(nullptr),
mId(INVALID_TRANSFORM_ID),
mValue(1.0f,0.0f,0.0f,0.0f)
{
/**
* Virtual destructor.
*/
- virtual ~TransformManagerQuaternionInput()
+ ~TransformManagerQuaternionInput() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Quaternion>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetQuaternion()
*/
- virtual const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetQuaternion( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::PropertyInput::GetConstraintInputQuaternion()
*/
- virtual const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const
+ const Quaternion& GetConstraintInputQuaternion( BufferIndex bufferIndex ) const override
{
ComputeTransformComponent();
return mValue;
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
* Constructor
*/
TransformManagerMatrixInput()
- :mTxManager(0),
+ :mTxManager(nullptr),
mId(INVALID_TRANSFORM_ID)
{
}
/**
* Virtual destructor.
*/
- virtual ~TransformManagerMatrixInput()
+ ~TransformManagerMatrixInput() override
{
}
/**
* @copydoc Dali::Internal::SceneGraph::PropertyBase::GetType()
*/
- virtual Dali::Property::Type GetType() const
+ Dali::Property::Type GetType() const override
{
return Dali::PropertyTypes::Get<Matrix>();
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::InputInitialized()
*/
- virtual bool InputInitialized() const
+ bool InputInitialized() const override
{
return true;
}
* @copydoc Dali::Internal::PropertyInputImpl::InputChanged()
* @note A constraint can only receive the inherited property from the previous frame.
*/
- virtual bool InputChanged() const
+ bool InputChanged() const override
{
return true;
}
/**
* @copydoc Dali::PropertyInput::GetMatrix()
*/
- virtual const Matrix& GetMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetMatrix( BufferIndex bufferIndex ) const override
{
if( mTxManager )
{
/**
* @copydoc Dali::PropertyInput::GetConstraintInputMatrix()
*/
- virtual const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetConstraintInputMatrix( BufferIndex bufferIndex ) const override
{
if( mTxManager )
{
*/
Matrix& Get( BufferIndex bufferIndex )
{
- DALI_ASSERT_ALWAYS( mTxManager != 0 );
+ DALI_ASSERT_ALWAYS( mTxManager != nullptr );
return mTxManager->GetWorldMatrix(mId);
}
/**
* @copydoc Dali::Internal::PropertyInputImpl::IsTransformManagerProperty()
*/
- virtual bool IsTransformManagerProperty() const
+ bool IsTransformManagerProperty() const override
{
return true;
}
TRANSFORM_PROPERTY_COUNT,
};
-typedef uint32_t TransformId; // 4,294,967,295 transforms supported
+using TransformId = uint32_t; // 4,294,967,295 transforms supported
static const TransformId INVALID_TRANSFORM_ID = -1;
} //SceneGraph
transformManager(),
animationPlaylist( animationPlaylist ),
propertyNotifier( propertyNotifier ),
- shaderSaver( NULL ),
+ shaderSaver( nullptr ),
discardQueue( discardQueue ),
renderController( renderController ),
- sceneController( NULL ),
+ sceneController( nullptr ),
renderManager( renderManager ),
renderQueue( renderQueue ),
renderTaskProcessor( renderTaskProcessor ),
renderers(),
textureSets(),
shaders(),
- panGestureProcessor( NULL ),
+ panGestureProcessor( nullptr ),
messageQueue( renderController, sceneGraphBuffers ),
- frameCallbackProcessor( NULL ),
+ frameCallbackProcessor( nullptr ),
keepRenderingSeconds( 0.0f ),
nodeDirtyFlags( NodePropertyFlags::TRANSFORM ), // set to TransformFlag to ensure full update the first time through Update()
frameCounter( 0 ),
sceneController = new SceneControllerImpl( renderMessageDispatcher, renderQueue, discardQueue );
// create first 'dummy' node
- nodes.PushBack(0u);
+ nodes.PushBack(nullptr);
}
~Impl()
RenderTaskList::RenderTaskContainer& tasks = scene->taskList->GetTasks();
for ( auto&& task : tasks )
{
- task->SetSourceNode( NULL );
+ task->SetSourceNode( nullptr );
}
}
}
RenderManager& renderManager,
RenderQueue& renderQueue,
RenderTaskProcessor& renderTaskProcessor )
- : mImpl(NULL)
+ : mImpl(nullptr)
{
mImpl = new Impl( notificationManager,
animationFinishedNotifier,
void UpdateManager::AddNode( OwnerPointer<Node>& node )
{
- DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
+ DALI_ASSERT_ALWAYS( nullptr == node->GetParent() ); // Should not have a parent yet
// Nodes must be sorted by pointer
Node* rawNode = node.Release();
void UpdateManager::ConnectNode( Node* parent, Node* node )
{
- DALI_ASSERT_ALWAYS( NULL != parent );
- DALI_ASSERT_ALWAYS( NULL != node );
- DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should not have a parent yet
+ DALI_ASSERT_ALWAYS( nullptr != parent );
+ DALI_ASSERT_ALWAYS( nullptr != node );
+ DALI_ASSERT_ALWAYS( nullptr == node->GetParent() ); // Should not have a parent yet
DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] ConnectNode\n", node );
DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DisconnectNode\n", node );
Node* parent = node->GetParent();
- DALI_ASSERT_ALWAYS( NULL != parent );
+ DALI_ASSERT_ALWAYS( nullptr != parent );
parent->SetDirtyFlag( NodePropertyFlags::CHILD_DELETED ); // make parent dirty so that render items dont get reused
parent->DisconnectChild( mSceneGraphBuffers.GetUpdateBufferIndex(), *node );
void UpdateManager::DestroyNode( Node* node )
{
- DALI_ASSERT_ALWAYS( NULL != node );
- DALI_ASSERT_ALWAYS( NULL == node->GetParent() ); // Should have been disconnected
+ DALI_ASSERT_ALWAYS( nullptr != node );
+ DALI_ASSERT_ALWAYS( nullptr == node->GetParent() ); // Should have been disconnected
DALI_LOG_INFO( gLogFilter, Debug::General, "[%x] DestroyNode\n", node );
void UpdateManager::RemoveScene( Scene* scene )
{
// Initialize the context from render manager
- typedef MessageValue1< RenderManager, SceneGraph::Scene* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, SceneGraph::Scene*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
{
if( shaderData )
{
-
- typedef MessageValue3< Shader, Internal::ShaderDataPtr, ProgramCache*, bool> DerivedType;
+ using DerivedType = MessageValue3<Shader, Internal::ShaderDataPtr, ProgramCache*, bool>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
(mImpl->nodeDirtyFlags & RenderableUpdateFlags) || // ..nodes were dirty in previous frame OR
IsAnimationRunning() || // ..at least one animation is running OR
mImpl->messageQueue.IsSceneUpdateRequired() || // ..a message that modifies the scene graph node tree is queued OR
+ mImpl->frameCallbackProcessor || // ..a frame callback processor is existed OR
gestureUpdated; // ..a gesture property was updated
bool keepRendererRendering = false;
{
mImpl->surfaceRectChanged = true;
- typedef MessageValue1< RenderManager, Rect<int32_t> > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Rect<int32_t> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SurfaceReplaced( Scene* scene )
{
- typedef MessageValue1< RenderManager, Scene* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Scene*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddSampler( OwnerPointer< Render::Sampler >& sampler )
{
// Message has ownership of Sampler while in transit from update to render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::Sampler > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Sampler> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveSampler( Render::Sampler* sampler )
{
- typedef MessageValue1< RenderManager, Render::Sampler* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Sampler*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetFilterMode( Render::Sampler* sampler, uint32_t minFilterMode, uint32_t magFilterMode )
{
- typedef MessageValue3< RenderManager, Render::Sampler*, uint32_t, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::Sampler*, uint32_t, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetWrapMode( Render::Sampler* sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
{
- typedef MessageValue4< RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > DerivedType;
+ using DerivedType = MessageValue4<RenderManager, Render::Sampler*, uint32_t, uint32_t, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddVertexBuffer( OwnerPointer< Render::VertexBuffer >& vertexBuffer )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::VertexBuffer > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::VertexBuffer> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveVertexBuffer( Render::VertexBuffer* vertexBuffer )
{
- typedef MessageValue1< RenderManager, Render::VertexBuffer* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::VertexBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetVertexBufferFormat( Render::VertexBuffer* vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue2< RenderManager, Render::VertexBuffer*, OwnerPointer< Render::VertexBuffer::Format > > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::VertexBuffer*, OwnerPointer<Render::VertexBuffer::Format> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetVertexBufferData( Render::VertexBuffer* vertexBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue3< RenderManager, Render::VertexBuffer*, OwnerPointer< Dali::Vector<uint8_t> >, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::VertexBuffer*, OwnerPointer<Dali::Vector<uint8_t> >, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddGeometry( OwnerPointer< Render::Geometry >& geometry )
{
// Message has ownership of format while in transit from update -> render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::Geometry > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Geometry> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveGeometry( Render::Geometry* geometry )
{
- typedef MessageValue1< RenderManager, Render::Geometry* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Geometry*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetGeometryType( Render::Geometry* geometry, uint32_t geometryType )
{
- typedef MessageValue2< RenderManager, Render::Geometry*, uint32_t > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::Geometry*, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::SetIndexBuffer( Render::Geometry* geometry, Dali::Vector<uint16_t>& indices )
{
- typedef IndexBufferMessage< RenderManager > DerivedType;
+ using DerivedType = IndexBufferMessage<RenderManager>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
{
- typedef MessageValue2< RenderManager, Render::Geometry*, Render::VertexBuffer* > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachVertexBuffer( Render::Geometry* geometry, Render::VertexBuffer* vertexBuffer )
{
- typedef MessageValue2< RenderManager, Render::Geometry*, Render::VertexBuffer* > DerivedType;
+ using DerivedType = MessageValue2<RenderManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddTexture( OwnerPointer< Render::Texture >& texture )
{
// Message has ownership of Texture while in transit from update -> render
- typedef MessageValue1< RenderManager, OwnerPointer< Render::Texture > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::Texture> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveTexture( Render::Texture* texture)
{
- typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::UploadTexture( Render::Texture* texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
{
- typedef MessageValue3< RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::Texture*, PixelDataPtr, Texture::UploadParams>;
// Reserve some memory inside the message queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::GenerateMipmaps( Render::Texture* texture )
{
- typedef MessageValue1< RenderManager, Render::Texture* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::Texture*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AddFrameBuffer( OwnerPointer< Render::FrameBuffer >& frameBuffer )
{
- typedef MessageValue1< RenderManager, OwnerPointer< Render::FrameBuffer > > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, OwnerPointer<Render::FrameBuffer> >;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::RemoveFrameBuffer( Render::FrameBuffer* frameBuffer)
{
- typedef MessageValue1< RenderManager, Render::FrameBuffer* > DerivedType;
+ using DerivedType = MessageValue1<RenderManager, Render::FrameBuffer*>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachColorTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
{
- typedef MessageValue4< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > DerivedType;
+ using DerivedType = MessageValue4<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachDepthTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
void UpdateManager::AttachDepthStencilTextureToFrameBuffer( Render::FrameBuffer* frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t > DerivedType;
+ using DerivedType = MessageValue3<RenderManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the render queue
uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot( mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof( DerivedType ) );
/**
* Destructor.
*/
- virtual ~UpdateManager();
+ ~UpdateManager() override;
// Node connection methods
* @brief Accept compiled shaders passed back on render thread for saving.
* @param[in] shaderData Source code, hash over source, and corresponding compiled binary to be saved.
*/
- virtual void SaveBinary( Internal::ShaderDataPtr shaderData );
+ void SaveBinary( Internal::ShaderDataPtr shaderData ) override;
/**
* @brief Set the destination for compiled shader binaries to be passed on to.
inline void InstallRootMessage( UpdateManager& manager, OwnerPointer<Layer>& root )
{
// Message has ownership of Layer while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer<Layer> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Layer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
Layer* root = const_cast< Layer* >( constRoot );
- typedef MessageValue1< UpdateManager, Layer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Layer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddNodeMessage( UpdateManager& manager, OwnerPointer<Node>& node )
{
// Message has ownership of Node while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer<Node> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Node> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
Node& parent = const_cast< Node& >( constParent );
Node& child = const_cast< Node& >( constChild );
- typedef MessageValue2< UpdateManager, Node*, Node* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Node*, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can modify this object.
Node& node = const_cast< Node& >( constNode );
- typedef MessageValue1< UpdateManager, Node* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
Node& node = const_cast< Node& >( constNode );
- typedef MessageValue1< UpdateManager, Node* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddCameraMessage( UpdateManager& manager, OwnerPointer< Camera >& camera )
{
// Message has ownership of Camera while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Camera > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Camera> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveCameraMessage( UpdateManager& manager, const Camera* camera )
{
- typedef MessageValue1< UpdateManager, Camera* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Camera*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddObjectMessage( UpdateManager& manager, OwnerPointer<PropertyOwner>& object )
{
// Message has ownership of object while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer<PropertyOwner> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<PropertyOwner> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveObjectMessage( UpdateManager& manager, const PropertyOwner* object )
{
- typedef MessageValue1< UpdateManager, PropertyOwner* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, PropertyOwner*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddAnimationMessage( UpdateManager& manager, OwnerPointer< SceneGraph::Animation >& animation )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::Animation > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<SceneGraph::Animation> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Animation& animation = const_cast< Animation& >( constAnimation );
- typedef MessageValue1< UpdateManager, Animation* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Animation*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Animation& animation = const_cast< Animation& >( constAnimation );
- typedef MessageValue1< UpdateManager, Animation* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Animation*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddRenderTaskListMessage( UpdateManager& manager, OwnerPointer< SceneGraph::RenderTaskList >& taskList )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::RenderTaskList > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<SceneGraph::RenderTaskList> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
RenderTaskList& taskList = const_cast< RenderTaskList& >( constTaskList );
- typedef MessageValue1< UpdateManager, RenderTaskList* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, RenderTaskList*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddSceneMessage( UpdateManager& manager, OwnerPointer< SceneGraph::Scene >& scene )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< SceneGraph::Scene > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<SceneGraph::Scene> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Scene& scene = const_cast< Scene& >( constScene );
- typedef MessageValue1< UpdateManager, Scene* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Scene*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddPropertyNotificationMessage( UpdateManager& manager, OwnerPointer< PropertyNotification >& propertyNotification )
{
// Message has ownership of PropertyNotification while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< PropertyNotification > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<PropertyNotification> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
PropertyNotification& propertyNotification = const_cast< PropertyNotification& >( constPropertyNotification );
- typedef MessageValue1< UpdateManager, PropertyNotification* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, PropertyNotification*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
PropertyNotification* propertyNotification = const_cast< PropertyNotification* >( constPropertyNotification );
- typedef MessageValue2< UpdateManager, PropertyNotification*, PropertyNotification::NotifyMode > LocalType;
+ using LocalType = MessageValue2<UpdateManager, PropertyNotification*, PropertyNotification::NotifyMode>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void AddShaderMessage( UpdateManager& manager, OwnerPointer< Shader >& shader )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< Shader > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Shader> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void RemoveShaderMessage( UpdateManager& manager, const Shader* shader )
{
- typedef MessageValue1< UpdateManager, Shader* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Shader*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
Internal::ShaderDataPtr shaderData,
bool modifiesGeometry )
{
- typedef MessageValue3< UpdateManager, Shader*, Internal::ShaderDataPtr, bool > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Shader*, Internal::ShaderDataPtr, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDefaultSurfaceRectMessage( UpdateManager& manager, const Rect<int32_t>& rect )
{
- typedef MessageValue1< UpdateManager, Rect<int32_t> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Rect<int32_t> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The scene-graph thread owns this object so it can safely edit it.
Scene& scene = const_cast< Scene& >( constScene );
- typedef MessageValue1< UpdateManager, Scene* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Scene*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void KeepRenderingMessage( UpdateManager& manager, float durationSeconds )
{
- typedef MessageValue1< UpdateManager, float > LocalType;
+ using LocalType = MessageValue1<UpdateManager, float>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRenderingBehaviorMessage( UpdateManager& manager, DevelStage::Rendering renderingBehavior )
{
- typedef MessageValue1< UpdateManager, DevelStage::Rendering > LocalType;
+ using LocalType = MessageValue1<UpdateManager, DevelStage::Rendering>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetLayerDepthsMessage( UpdateManager& manager, const std::vector< Layer* >& layers, const Layer* rootLayer )
{
- typedef MessageValue2< UpdateManager, std::vector< Layer* >, const Layer* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, std::vector<Layer*>, const Layer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddRendererMessage( UpdateManager& manager, OwnerPointer< Renderer >& object )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< Renderer > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Renderer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveRendererMessage( UpdateManager& manager, const Renderer& object )
{
- typedef MessageValue1< UpdateManager, Renderer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Renderer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void AddTextureSetMessage( UpdateManager& manager, OwnerPointer< TextureSet >& textureSet )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< TextureSet > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<TextureSet> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
// The render thread can safely change the Shader
inline void RemoveTextureSetMessage( UpdateManager& manager, TextureSet& textureSet )
{
- typedef MessageValue1< UpdateManager, TextureSet* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, TextureSet*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddSamplerMessage( UpdateManager& manager, OwnerPointer< Render::Sampler >& sampler )
{
// Message has ownership of Sampler while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::Sampler > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::Sampler> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveSamplerMessage( UpdateManager& manager, Render::Sampler& sampler )
{
- typedef MessageValue1< UpdateManager, Render::Sampler* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Sampler*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetFilterModeMessage( UpdateManager& manager, Render::Sampler& sampler, uint32_t minFilterMode, uint32_t magFilterMode )
{
- typedef MessageValue3< UpdateManager, Render::Sampler*, uint32_t, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::Sampler*, uint32_t, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetWrapModeMessage( UpdateManager& manager, Render::Sampler& sampler, uint32_t rWrapMode, uint32_t sWrapMode, uint32_t tWrapMode )
{
- typedef MessageValue4< UpdateManager, Render::Sampler*, uint32_t, uint32_t, uint32_t > LocalType;
+ using LocalType = MessageValue4<UpdateManager, Render::Sampler*, uint32_t, uint32_t, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddVertexBuffer( UpdateManager& manager, OwnerPointer< Render::VertexBuffer >& vertexBuffer )
{
// Message has ownership of vertexBuffer while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::VertexBuffer > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::VertexBuffer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveVertexBuffer( UpdateManager& manager, Render::VertexBuffer& vertexBuffer )
{
- typedef MessageValue1< UpdateManager, Render::VertexBuffer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::VertexBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetVertexBufferFormat( UpdateManager& manager, Render::VertexBuffer& vertexBuffer, OwnerPointer< Render::VertexBuffer::Format>& format )
{
// Message has ownership of VertexBuffer::Format while in transit from event -> update
- typedef MessageValue2< UpdateManager, Render::VertexBuffer*, OwnerPointer< Render::VertexBuffer::Format> > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::VertexBuffer*, OwnerPointer<Render::VertexBuffer::Format> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetVertexBufferData( UpdateManager& manager, Render::VertexBuffer& vertexBuffer, OwnerPointer< Vector<uint8_t> >& data, uint32_t size )
{
// Message has ownership of VertexBuffer data while in transit from event -> update
- typedef MessageValue3< UpdateManager, Render::VertexBuffer*, OwnerPointer< Vector<uint8_t> >, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::VertexBuffer*, OwnerPointer<Vector<uint8_t> >, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddGeometry( UpdateManager& manager, OwnerPointer< Render::Geometry >& geometry )
{
// Message has ownership of Geometry while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::Geometry > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::Geometry> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveGeometry( UpdateManager& manager, Render::Geometry& geometry )
{
- typedef MessageValue1< UpdateManager, Render::Geometry* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Geometry*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::VertexBuffer& vertexBuffer )
{
- typedef MessageValue2< UpdateManager, Render::Geometry*, Render::VertexBuffer* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveVertexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, const Render::VertexBuffer& vertexBuffer )
{
- typedef MessageValue2< UpdateManager, Render::Geometry*, Render::VertexBuffer* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::Geometry*, Render::VertexBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
/**
* Virtual destructor
*/
- virtual ~IndexBufferMessage()
+ ~IndexBufferMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex /*bufferIndex*/ )
+ void Process( BufferIndex /*bufferIndex*/ ) override
{
DALI_ASSERT_DEBUG( mManager && "Message does not have an object" );
mManager->SetIndexBuffer( mRenderGeometry, mIndices );
inline void SetIndexBufferMessage( UpdateManager& manager, Render::Geometry& geometry, Dali::Vector<uint16_t>& indices )
{
- typedef IndexBufferMessage< UpdateManager > LocalType;
+ using LocalType = IndexBufferMessage<UpdateManager>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetGeometryTypeMessage( UpdateManager& manager, Render::Geometry& geometry, uint32_t geometryType )
{
- typedef MessageValue2< UpdateManager, Render::Geometry*, uint32_t > LocalType;
+ using LocalType = MessageValue2<UpdateManager, Render::Geometry*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddTexture( UpdateManager& manager, OwnerPointer< Render::Texture >& texture )
{
// Message has ownership of Texture while in transit from event -> update
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::Texture > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::Texture> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveTexture( UpdateManager& manager, Render::Texture& texture )
{
- typedef MessageValue1< UpdateManager, Render::Texture* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Texture*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void UploadTextureMessage( UpdateManager& manager, Render::Texture& texture, PixelDataPtr pixelData, const Texture::UploadParams& params )
{
- typedef MessageValue3< UpdateManager, Render::Texture*, PixelDataPtr, Texture::UploadParams > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::Texture*, PixelDataPtr, Texture::UploadParams>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void GenerateMipmapsMessage( UpdateManager& manager, Render::Texture& texture )
{
- typedef MessageValue1< UpdateManager, Render::Texture* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::Texture*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddFrameBuffer( UpdateManager& manager, OwnerPointer< Render::FrameBuffer >& frameBuffer )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< Render::FrameBuffer > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<Render::FrameBuffer> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer )
{
- typedef MessageValue1< UpdateManager, Render::FrameBuffer* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, Render::FrameBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachColorTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, uint32_t mipmapLevel, uint32_t layer )
{
- typedef MessageValue4< UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t > LocalType;
+ using LocalType = MessageValue4<UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachDepthTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachDepthStencilTextureToFrameBuffer( UpdateManager& manager, Render::FrameBuffer& frameBuffer, Render::Texture* texture, uint32_t mipmapLevel )
{
- typedef MessageValue3< UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t > LocalType;
+ using LocalType = MessageValue3<UpdateManager, Render::FrameBuffer*, Render::Texture*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthIndicesMessage( UpdateManager& manager, OwnerPointer< NodeDepths >& nodeDepths )
{
- typedef MessageValue1< UpdateManager, OwnerPointer< NodeDepths > > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<NodeDepths> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddResetterMessage( UpdateManager& manager, OwnerPointer<PropertyResetterBase> resetter )
{
- typedef MessageValue1< UpdateManager, OwnerPointer<PropertyResetterBase> > LocalType;
+ using LocalType = MessageValue1<UpdateManager, OwnerPointer<PropertyResetterBase> >;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void AddFrameCallbackMessage( UpdateManager& manager, OwnerPointer< FrameCallback >& frameCallback, const Node& rootNode )
{
- typedef MessageValue2< UpdateManager, OwnerPointer< FrameCallback >, const Node* > LocalType;
+ using LocalType = MessageValue2<UpdateManager, OwnerPointer<FrameCallback>, const Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
inline void RemoveFrameCallbackMessage( UpdateManager& manager, FrameCallbackInterface& frameCallback )
{
- typedef MessageValue1< UpdateManager, FrameCallbackInterface* > LocalType;
+ using LocalType = MessageValue1<UpdateManager, FrameCallbackInterface*>;
// Reserve some memory inside the message queue
uint32_t* slot = manager.ReserveMessageSlot( sizeof( LocalType ) );
SceneGraph::Node* FindNodeInSceneGraph( uint32_t id, SceneGraph::Node& node )
{
- SceneGraph::Node* matchingNode = NULL;
+ SceneGraph::Node* matchingNode = nullptr;
if( node.mId == id )
{
UpdateProxy::UpdateProxy( SceneGraph::UpdateManager& updateManager, SceneGraph::TransformManager& transformManager, SceneGraph::Node& rootNode )
: mNodeContainer(),
- mLastCachedIdNodePair( { 0u, NULL } ),
+ mLastCachedIdNodePair( { 0u, nullptr } ),
mCurrentBufferIndex( 0u ),
mUpdateManager( updateManager ),
mTransformManager( transformManager ),
void UpdateProxy::NodeHierarchyChanged()
{
- mLastCachedIdNodePair = { 0u, NULL };
+ mLastCachedIdNodePair = { 0u, nullptr };
mNodeContainer.clear();
mPropertyModifier.reset();
}
SceneGraph::Node* UpdateProxy::GetNodeWithId( uint32_t id ) const
{
- SceneGraph::Node* node = NULL;
+ SceneGraph::Node* node = nullptr;
// Cache the last accessed node so we don't have to traverse
if( mLastCachedIdNodePair.node && mLastCachedIdNodePair.id == id )
class Node;
-typedef Dali::Vector< Node* > NodeContainer;
-typedef NodeContainer::Iterator NodeIter;
-typedef NodeContainer::ConstIterator NodeConstIter;
+using NodeContainer = Dali::Vector<Node *>;
+using NodeIter = NodeContainer::Iterator;
+using NodeConstIter = NodeContainer::ConstIterator;
/**
* Flag whether property has changed, during the Update phase.
/**
* Virtual destructor
*/
- virtual ~NodePropertyMessageBase();
+ ~NodePropertyMessageBase() override;
private:
class NodePropertyMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, typename ParameterType< P >::PassingType );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, typename ParameterType<P>::PassingType );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~NodePropertyMessage()
+ ~NodePropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class NodePropertyComponentMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(AnimatableProperty<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( AnimatableProperty<P>::* )( BufferIndex, float );
/**
* Send a message.
/**
* Virtual destructor
*/
- virtual ~NodePropertyComponentMessage()
+ ~NodePropertyComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class NodeTransformPropertyMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(TransformManagerPropertyHandler<P>::*MemberFunction)( BufferIndex, const P& );
+ using MemberFunction = void ( TransformManagerPropertyHandler<P>::* )( BufferIndex, const P& );
/**
* Create a message.
/**
* Virtual destructor
*/
- virtual ~NodeTransformPropertyMessage()
+ ~NodeTransformPropertyMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
class NodeTransformComponentMessage : public NodePropertyMessageBase
{
public:
-
- typedef void(TransformManagerPropertyHandler<P>::*MemberFunction)( BufferIndex, float );
+ using MemberFunction = void ( TransformManagerPropertyHandler<P>::* )( BufferIndex, float );
/**
* Send a message.
/**
* Virtual destructor
*/
- virtual ~NodeTransformComponentMessage()
+ ~NodeTransformComponentMessage() override
{
}
/**
* @copydoc MessageBase::Process
*/
- virtual void Process( BufferIndex updateBufferIndex )
+ void Process( BufferIndex updateBufferIndex ) override
{
(mProperty->*mMemberFunction)( updateBufferIndex, mParam );
}
}
Node::Node()
-: mTransformManager( NULL ),
+: mTransformManager( nullptr ),
mTransformId( INVALID_TRANSFORM_ID ),
mParentOrigin( TRANSFORM_PROPERTY_PARENT_ORIGIN ),
mAnchorPoint( TRANSFORM_PROPERTY_ANCHOR_POINT ),
mWorldColor( Color::WHITE ),
mClippingSortModifier( 0u ),
mId( ++mNodeCounter ),
- mParent( NULL ),
- mExclusiveRenderTask( NULL ),
+ mParent( nullptr ),
+ mExclusiveRenderTask( nullptr ),
mChildren(),
mClippingDepth( 0u ),
mScissorDepth( 0u ),
mRegenerateUniformMap = 2;
}
+bool Node::IsAnimationPossible() const
+{
+ return mIsConnectedToSceneGraph;
+}
+
void Node::PrepareRender( BufferIndex bufferIndex )
{
if( mRegenerateUniformMap != 0 )
void Node::ConnectChild( Node* childNode )
{
DALI_ASSERT_ALWAYS( this != childNode );
- DALI_ASSERT_ALWAYS( IsRoot() || NULL != mParent ); // Parent should be connected first
- DALI_ASSERT_ALWAYS( !childNode->IsRoot() && NULL == childNode->GetParent() ); // Child should be disconnected
+ DALI_ASSERT_ALWAYS( IsRoot() || nullptr != mParent ); // Parent should be connected first
+ DALI_ASSERT_ALWAYS( !childNode->IsRoot() && nullptr == childNode->GetParent() ); // Child should be disconnected
childNode->SetParent( *this );
DALI_ASSERT_ALWAYS( childNode.GetParent() == this );
// Find the childNode and remove it
- Node* found( NULL );
+ Node* found( nullptr );
const NodeIter endIter = mChildren.End();
for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
break; // iter is no longer valid
}
}
- DALI_ASSERT_ALWAYS( NULL != found );
+ DALI_ASSERT_ALWAYS( nullptr != found );
found->RecursiveDisconnectFromSceneGraph( updateBufferIndex );
}
{
DALI_ASSERT_ALWAYS(this != &parentNode);
DALI_ASSERT_ALWAYS(!mIsRoot);
- DALI_ASSERT_ALWAYS(mParent == NULL);
+ DALI_ASSERT_ALWAYS(mParent == nullptr);
mParent = &parentNode;
void Node::RecursiveDisconnectFromSceneGraph( BufferIndex updateBufferIndex )
{
DALI_ASSERT_ALWAYS(!mIsRoot);
- DALI_ASSERT_ALWAYS(mParent != NULL);
+ DALI_ASSERT_ALWAYS(mParent != nullptr);
const NodeIter endIter = mChildren.End();
for ( NodeIter iter = mChildren.Begin(); iter != endIter; ++iter )
PropertyOwner::DisconnectFromSceneGraph( updateBufferIndex );
// Remove back-pointer to parent
- mParent = NULL;
+ mParent = nullptr;
// Remove all child pointers
mChildren.Clear();
*/
virtual Layer* GetLayer()
{
- return NULL;
+ return nullptr;
}
/**
* @param[in] updated The updated flag
* (used for partial rendering to mark an animating sub tree for example).
*/
- virtual void SetUpdated(bool updated)
+ void SetUpdated(bool updated) override
{
mUpdated = updated;
/**
* @copydoc UniformMap::Add
*/
- void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map );
+ void AddUniformMapping( OwnerPointer< UniformPropertyMapping >& map ) override;
/**
* @copydoc UniformMap::Remove
*/
- void RemoveUniformMapping( const std::string& uniformName );
+ void RemoveUniformMapping( const std::string& uniformName ) override;
+
+ /**
+ * @copydoc Dali::Internal::SceneGraph::PropertyOwner::IsAnimationPossible
+ */
+ bool IsAnimationPossible() const override;
/**
* Prepare the node for rendering.
* Protected virtual destructor; See also Node::Delete( Node* )
* Kept protected to allow destructor chaining from layer
*/
- virtual ~Node();
+ ~Node() override;
private: // from NodeDataProvider
/**
* @copydoc NodeDataProvider::GetModelMatrix
*/
- virtual const Matrix& GetModelMatrix( BufferIndex bufferIndex ) const
+ const Matrix& GetModelMatrix( BufferIndex bufferIndex ) const override
{
return GetWorldMatrix( bufferIndex );
}
/**
* @copydoc NodeDataProvider::GetRenderColor
*/
- virtual const Vector4& GetRenderColor( BufferIndex bufferIndex ) const
+ const Vector4& GetRenderColor( BufferIndex bufferIndex ) const override
{
return GetWorldColor( bufferIndex );
}
/**
* @copydoc UniformMapDataProvider::GetUniformMapChanged
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override
{
return mUniformMapChanged[bufferIndex];
}
/**
* @copydoc UniformMapDataProvider::GetUniformMap
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override
{
return mCollectedUniformMap[bufferIndex];
}
inline void SetInheritOrientationMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetParentOriginMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& origin )
{
- typedef MessageValue1< Node, Vector3 > LocalType;
+ using LocalType = MessageValue1<Node, Vector3>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetAnchorPointMessage( EventThreadServices& eventThreadServices, const Node& node, const Vector3& anchor )
{
- typedef MessageValue1< Node, Vector3 > LocalType;
+ using LocalType = MessageValue1<Node, Vector3>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetInheritPositionMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetInheritScaleMessage( EventThreadServices& eventThreadServices, const Node& node, bool inherit )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetColorModeMessage( EventThreadServices& eventThreadServices, const Node& node, ColorMode colorMode )
{
- typedef MessageValue1< Node, ColorMode > LocalType;
+ using LocalType = MessageValue1<Node, ColorMode>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDrawModeMessage( EventThreadServices& eventThreadServices, const Node& node, DrawMode::Type drawMode )
{
- typedef MessageValue1< Node, DrawMode::Type > LocalType;
+ using LocalType = MessageValue1<Node, DrawMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void AttachRendererMessage( EventThreadServices& eventThreadServices, const Node& node, const Renderer& renderer )
{
- typedef MessageValue1< Node, Renderer* > LocalType;
+ using LocalType = MessageValue1<Node, Renderer*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void DetachRendererMessage( EventThreadServices& eventThreadServices, const Node& node, const Renderer& renderer )
{
- typedef MessageValue1< Node, const Renderer* > LocalType;
+ using LocalType = MessageValue1<Node, const Renderer*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Node& node, uint32_t depthIndex )
{
- typedef MessageValue1< Node, uint32_t > LocalType;
+ using LocalType = MessageValue1<Node, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetClippingModeMessage( EventThreadServices& eventThreadServices, const Node& node, ClippingMode::Type clippingMode )
{
- typedef MessageValue1< Node, ClippingMode::Type > LocalType;
+ using LocalType = MessageValue1<Node, ClippingMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetPositionUsesAnchorPointMessage( EventThreadServices& eventThreadServices, const Node& node, bool positionUsesAnchorPoint )
{
- typedef MessageValue1< Node, bool > LocalType;
+ using LocalType = MessageValue1<Node, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
template <>
inline void OwnerPointer<Dali::Internal::SceneGraph::Node>::Reset()
{
- if (mObject != NULL)
+ if (mObject != nullptr)
{
Dali::Internal::SceneGraph::Node::Delete(mObject);
- mObject = NULL;
+ mObject = nullptr;
}
}
} // namespace Internal
: Node(),
mSortFunction( Internal::Layer::ZValue ),
mClippingBox( 0,0,0,0 ),
- mLastCamera( NULL ),
+ mLastCamera( nullptr ),
mBehavior( Dali::Layer::LAYER_UI ),
mIsClipping( false ),
mDepthTestDisabled( true ),
struct Renderable
{
Renderable()
- : mNode( 0 ),
- mRenderer( 0 )
+ : mNode( nullptr ),
+ mRenderer( nullptr )
{}
Renderable( Node* node, Renderer* renderer )
Renderer* mRenderer;
};
-typedef Dali::Vector< Renderable > RenderableContainer;
+using RenderableContainer = Dali::Vector<Renderable>;
/**
* Layers have a "depth" relative to all other layers in the scene-graph.
class Layer : public Node
{
public:
-
- typedef Dali::Layer::SortFunctionType SortFunctionType;
+ using SortFunctionType = Dali::Layer::SortFunctionType;
// Creation methods
/**
* Virtual destructor
*/
- virtual ~Layer();
+ ~Layer() override;
/**
* From Node, to convert a node to a layer.
* @return The layer.
*/
- virtual Layer* GetLayer()
+ Layer* GetLayer() override
{
return this;
}
*/
inline void SetSortFunctionMessage( EventThreadServices& eventThreadServices, const Layer& layer, Dali::Layer::SortFunctionType function )
{
- typedef MessageValue1< Layer, Dali::Layer::SortFunctionType > LocalType;
+ using LocalType = MessageValue1<Layer, Dali::Layer::SortFunctionType>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetClippingMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool enabled )
{
- typedef MessageValue1< Layer, bool > LocalType;
+ using LocalType = MessageValue1<Layer, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetClippingBoxMessage( EventThreadServices& eventThreadServices, const Layer& layer, const Dali::ClippingBox& clippingbox )
{
- typedef MessageValue1< Layer, Dali::ClippingBox > LocalType;
+ using LocalType = MessageValue1<Layer, Dali::ClippingBox>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
const Layer& layer,
Dali::Layer::Behavior behavior )
{
- typedef MessageValue1< Layer, Dali::Layer::Behavior > LocalType;
+ using LocalType = MessageValue1<Layer, Dali::Layer::Behavior>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
*/
inline void SetDepthTestDisabledMessage( EventThreadServices& eventThreadServices, const Layer& layer, bool disable )
{
- typedef MessageValue1< Layer, bool > LocalType;
+ using LocalType = MessageValue1<Layer, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
template <>
inline void OwnerPointer<Dali::Internal::SceneGraph::Layer>::Reset()
{
- if (mObject != NULL)
+ if (mObject != nullptr)
{
Dali::Internal::SceneGraph::Node::Delete(mObject);
- mObject = NULL;
+ mObject = nullptr;
}
}
} // namespace Internal
// A queue of message buffers
typedef vector< MessageBuffer* > MessageBufferQueue;
-typedef MessageBufferQueue::iterator MessageBufferIter;
+using MessageBufferIter = MessageBufferQueue::iterator;
-typedef Dali::Mutex MessageQueueMutex;
+using MessageQueueMutex = Dali::Mutex;
} // unnamed namespace
queueWasEmpty(true),
sceneUpdateFlag( false ),
sceneUpdate( 0 ),
- currentMessageBuffer(NULL)
+ currentMessageBuffer(nullptr)
{
}
};
MessageQueue::MessageQueue( Integration::RenderController& controller, const SceneGraph::SceneGraphBuffers& buffers )
-: mImpl(NULL)
+: mImpl(nullptr)
{
mImpl = new Impl( controller, buffers );
}
// Called from event thread
bool MessageQueue::FlushQueue()
{
- const bool messagesToProcess = ( NULL != mImpl->currentMessageBuffer );
+ const bool messagesToProcess = ( nullptr != mImpl->currentMessageBuffer );
// If there're messages to flush
if ( messagesToProcess )
MessageQueueMutex::ScopedLock lock( mImpl->queueMutex );
mImpl->processQueue.push_back( mImpl->currentMessageBuffer );
- mImpl->currentMessageBuffer = NULL;
+ mImpl->currentMessageBuffer = nullptr;
// Grab any recycled MessageBuffers
while ( !mImpl->recycleQueue.empty() )
Camera::Camera()
: mUpdateViewFlag( UPDATE_COUNT ),
mUpdateProjectionFlag( UPDATE_COUNT ),
- mNode( NULL ),
+ mNode( nullptr ),
mType( DEFAULT_TYPE ),
mProjectionMode( DEFAULT_MODE ),
mInvertYAxis( DEFAULT_INVERT_Y_AXIS ),
inline void SetTypeMessage( EventThreadServices& eventThreadServices, const Camera& camera, Dali::Camera::Type parameter )
{
- typedef MessageValue1< Camera, Dali::Camera::Type > LocalType;
+ using LocalType = MessageValue1<Camera, Dali::Camera::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetProjectionModeMessage( EventThreadServices& eventThreadServices, const Camera& camera, Dali::Camera::ProjectionMode parameter )
{
- typedef MessageValue1< Camera, Dali::Camera::ProjectionMode > LocalProjectionMode;
+ using LocalProjectionMode = MessageValue1<Camera, Dali::Camera::ProjectionMode>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalProjectionMode ) );
inline void SetFieldOfViewMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetAspectRatioMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetLeftClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRightClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetTopClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBottomClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetNearClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetFarClippingPlaneMessage( EventThreadServices& eventThreadServices, const Camera& camera, float parameter )
{
- typedef MessageValue1< Camera, float > LocalType;
+ using LocalType = MessageValue1<Camera, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetTargetPositionMessage( EventThreadServices& eventThreadServices, const Camera& camera, const Vector3& parameter )
{
- typedef MessageValue1< Camera, Vector3 > LocalType;
+ using LocalType = MessageValue1<Camera, Vector3>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetInvertYAxisMessage( EventThreadServices& eventThreadServices, const Camera& camera, bool parameter )
{
- typedef MessageValue1< Camera, bool > LocalType;
+ using LocalType = MessageValue1<Camera, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
}
RenderTaskList::RenderTaskList()
-: mNotificationObject( NULL ),
- mRenderMessageDispatcher( NULL )
+: mNotificationObject( nullptr ),
+ mRenderMessageDispatcher( nullptr )
{
}
class RenderTaskList
{
public:
-
- typedef OwnerContainer< RenderTask* > RenderTaskContainer;
+ using RenderTaskContainer = OwnerContainer<RenderTask*>;
/**
* Construct a new RenderTaskList.
inline void AddTaskMessage( EventThreadServices& eventThreadServices, const RenderTaskList& list, OwnerPointer< RenderTask >& task )
{
// Message has ownership of the RenderTask while in transit from event -> update
- typedef MessageValue1< RenderTaskList, OwnerPointer< RenderTask > > LocalType;
+ using LocalType = MessageValue1<RenderTaskList, OwnerPointer<RenderTask> >;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
RenderTask& task = const_cast< RenderTask& >( constTask );
- typedef MessageValue1< RenderTaskList, RenderTask* > LocalType;
+ using LocalType = MessageValue1<RenderTaskList, RenderTask*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
mSourceNode( nullptr ),
mCameraNode( nullptr ),
mCamera( nullptr ),
- mFrameBuffer(0),
+ mFrameBuffer(nullptr),
mRefreshRate( Dali::RenderTask::DEFAULT_REFRESH_RATE ),
mFrameCounter( 0u ),
mRenderedOnceCounter( 0u ),
/**
* Virtual destructor
*/
- virtual ~RenderTask();
+ ~RenderTask() override;
/**
* Initialize the render task. Called in update thread
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerConnected( PropertyOwner& owner )
*/
- void PropertyOwnerConnected( PropertyOwner& owner );
+ void PropertyOwnerConnected( PropertyOwner& owner ) override;
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner )
*/
- void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner );
+ void PropertyOwnerDisconnected( BufferIndex updateBufferIndex, PropertyOwner& owner ) override;
/**
* @copydoc PropertyOwner::Observer::PropertyOwnerDestroyed( PropertyOwner& owner )
*/
- void PropertyOwnerDestroyed( PropertyOwner& owner );
+ void PropertyOwnerDestroyed( PropertyOwner& owner ) override;
private:
// Messages for RenderTask
inline void SetFrameBufferMessage( EventThreadServices& eventThreadServices, const RenderTask& task, Render::FrameBuffer* frameBuffer )
{
- typedef MessageValue1< RenderTask, Render::FrameBuffer*> LocalType;
+ using LocalType = MessageValue1<RenderTask, Render::FrameBuffer*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetClearColorMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector4& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector4 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector4>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeClearColorMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector4& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector4 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector4>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetClearEnabledMessage( EventThreadServices& eventThreadServices, const RenderTask& task, bool enabled )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetCullModeMessage( EventThreadServices& eventThreadServices, const RenderTask& task, bool mode )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRefreshRateMessage( EventThreadServices& eventThreadServices, const RenderTask& task, uint32_t refreshRate )
{
- typedef MessageValue1< RenderTask, uint32_t > LocalType;
+ using LocalType = MessageValue1<RenderTask, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
// Scene graph thread can destroy this object.
Node* node = const_cast< Node* >( constNode );
- typedef MessageValue1< RenderTask, Node* > LocalType;
+ using LocalType = MessageValue1<RenderTask, Node*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetCameraMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Node* constNode, const Camera* constCamera )
{
- typedef MessageValue2< RenderTask, Node*, Camera* > LocalType;
+ using LocalType = MessageValue2<RenderTask, Node*, Camera*>;
Node* node = const_cast< Node* >( constNode );
Camera* camera = const_cast< Camera* >( constCamera );
inline void SetExclusiveMessage( EventThreadServices& eventThreadServices, const RenderTask& task, bool exclusive )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetSyncRequiredMessage(EventThreadServices& eventThreadServices, const RenderTask& task, bool requiresSync )
{
- typedef MessageValue1< RenderTask, bool > LocalType;
+ using LocalType = MessageValue1<RenderTask, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeViewportPositionMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector2& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector2 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector2>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeViewportSizeMessage( EventThreadServices& eventThreadServices, const RenderTask& task, const Vector2& value )
{
- typedef MessageDoubleBuffered1< RenderTask, Vector2 > LocalType;
+ using LocalType = MessageDoubleBuffered1<RenderTask, Vector2>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
}
Renderer::Renderer()
-: mSceneController( 0 ),
- mRenderer( NULL ),
- mTextureSet( NULL ),
- mGeometry( NULL ),
- mShader( NULL ),
- mRenderDataProvider( NULL ),
- mBlendColor( NULL ),
+: mSceneController( nullptr ),
+ mRenderer( nullptr ),
+ mTextureSet( nullptr ),
+ mGeometry( nullptr ),
+ mShader( nullptr ),
+ mRenderDataProvider( nullptr ),
+ mBlendColor( nullptr ),
mStencilParameters( RenderMode::AUTO, StencilFunction::ALWAYS, 0xFF, 0x00, 0xFF, StencilOperation::KEEP, StencilOperation::KEEP, StencilOperation::KEEP ),
mIndexedDrawFirstElement( 0u ),
mIndexedDrawElementsCount( 0u ),
if( mTextureSet )
{
mTextureSet->RemoveObserver( this );
- mTextureSet = NULL;
+ mTextureSet = nullptr;
}
if( mShader )
{
mShader->RemoveConnectionObserver( *this );
- mShader = NULL;
+ mShader = nullptr;
}
}
if( mResendFlag & RESEND_DRAW_COMMANDS )
{
- typedef MessageValue2< Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t > DerivedType;
+ using DerivedType = MessageValue2<Render::Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDrawCommands, mDrawCommands.data(), mDrawCommands.size() );
}
if( mResendFlag & RESEND_FACE_CULLING_MODE )
{
- typedef MessageValue1< Render::Renderer, FaceCullingMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, FaceCullingMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetFaceCullingMode, mFaceCullingMode );
}
if( mResendFlag & RESEND_BLEND_BIT_MASK )
{
- typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendingBitMask, mBlendBitmask );
}
if( mResendFlag & RESEND_BLEND_COLOR )
{
- typedef MessageValue1< Render::Renderer, Vector4 > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, Vector4>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetBlendColor, GetBlendColor() );
}
if( mResendFlag & RESEND_PREMULTIPLIED_ALPHA )
{
- typedef MessageValue1< Render::Renderer, bool > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, bool>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::EnablePreMultipliedAlpha, mPremultipledAlphaEnabled );
}
if( mResendFlag & RESEND_INDEXED_DRAW_FIRST_ELEMENT )
{
- typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawFirstElement, mIndexedDrawFirstElement );
}
if( mResendFlag & RESEND_INDEXED_DRAW_ELEMENTS_COUNT )
{
- typedef MessageValue1< Render::Renderer, uint32_t > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, uint32_t>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetIndexedDrawElementsCount, mIndexedDrawElementsCount );
}
if( mResendFlag & RESEND_DEPTH_WRITE_MODE )
{
- typedef MessageValue1< Render::Renderer, DepthWriteMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, DepthWriteMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthWriteMode, mDepthWriteMode );
}
if( mResendFlag & RESEND_DEPTH_TEST_MODE )
{
- typedef MessageValue1< Render::Renderer, DepthTestMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, DepthTestMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthTestMode, mDepthTestMode );
}
if( mResendFlag & RESEND_DEPTH_FUNCTION )
{
- typedef MessageValue1< Render::Renderer, DepthFunction::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, DepthFunction::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetDepthFunction, mDepthFunction );
}
if( mResendFlag & RESEND_RENDER_MODE )
{
- typedef MessageValue1< Render::Renderer, RenderMode::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, RenderMode::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetRenderMode, mStencilParameters.renderMode );
}
if( mResendFlag & RESEND_STENCIL_FUNCTION )
{
- typedef MessageValue1< Render::Renderer, StencilFunction::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilFunction::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunction, mStencilParameters.stencilFunction );
}
if( mResendFlag & RESEND_STENCIL_FUNCTION_MASK )
{
- typedef MessageValue1< Render::Renderer, int > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionMask, mStencilParameters.stencilFunctionMask );
}
if( mResendFlag & RESEND_STENCIL_FUNCTION_REFERENCE )
{
- typedef MessageValue1< Render::Renderer, int > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilFunctionReference, mStencilParameters.stencilFunctionReference );
}
if( mResendFlag & RESEND_STENCIL_MASK )
{
- typedef MessageValue1< Render::Renderer, int > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, int>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilMask, mStencilParameters.stencilMask );
}
if( mResendFlag & RESEND_STENCIL_OPERATION_ON_FAIL )
{
- typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnFail, mStencilParameters.stencilOperationOnFail );
}
if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_FAIL )
{
- typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZFail, mStencilParameters.stencilOperationOnZFail );
}
if( mResendFlag & RESEND_STENCIL_OPERATION_ON_Z_PASS )
{
- typedef MessageValue1< Render::Renderer, StencilOperation::Type > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, StencilOperation::Type>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetStencilOperationOnZPass, mStencilParameters.stencilOperationOnZPass );
}
if( mResendFlag & RESEND_SHADER )
{
- typedef MessageValue1< Render::Renderer, bool > DerivedType;
+ using DerivedType = MessageValue1<Render::Renderer, bool>;
uint32_t* slot = mSceneController->GetRenderQueue().ReserveMessageSlot( updateBufferIndex, sizeof( DerivedType ) );
new (slot) DerivedType( mRenderer, &Render::Renderer::SetShaderChanged, true );
}
{
if( blendColor == Color::TRANSPARENT )
{
- mBlendColor = NULL;
+ mBlendColor = nullptr;
}
else
{
if( mRenderer )
{
mSceneController->GetRenderMessageDispatcher().RemoveRenderer( *mRenderer );
- mRenderer = NULL;
+ mRenderer = nullptr;
}
- mSceneController = NULL;
- mRenderDataProvider = NULL;
+ mSceneController = nullptr;
+ mRenderDataProvider = nullptr;
}
void Renderer::UpdateTextureSet()
void Renderer::TextureSetDeleted()
{
- mTextureSet = NULL;
+ mTextureSet = nullptr;
mRegenerateUniformMap = REGENERATE_UNIFORM_MAP;
{
if( reinterpret_cast<PropertyOwner*>(mShader) == &owner )
{
- mShader = NULL;
+ mShader = nullptr;
}
}
class SceneController;
class Renderer;
-typedef Dali::Vector< Renderer* > RendererContainer;
-typedef RendererContainer::Iterator RendererIter;
-typedef RendererContainer::ConstIterator RendererConstIter;
+using RendererContainer = Dali::Vector<Renderer*>;
+using RendererIter = RendererContainer::Iterator;
+using RendererConstIter = RendererContainer::ConstIterator;
class TextureSet;
class Geometry;
/**
* Destructor
*/
- virtual ~Renderer();
+ ~Renderer() override;
/**
* Overriden delete operator
/**
* @copydoc UniformMap::Observer::UniformMappingsChanged
*/
- virtual void UniformMappingsChanged( const UniformMap& mappings );
+ void UniformMappingsChanged( const UniformMap& mappings ) override;
public: // ConnectionChangePropagator::Observer
/**
* @copydoc ConnectionChangePropagator::ConnectionsChanged
*/
- virtual void ConnectionsChanged( PropertyOwner& owner );
+ void ConnectionsChanged( PropertyOwner& owner ) override;
/**
* @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
*/
- virtual void ConnectedUniformMapChanged( );
+ void ConnectedUniformMapChanged( ) override;
/**
* @copydoc ConnectionChangePropagator::ConnectedUniformMapChanged
*/
- virtual void ObservedObjectDestroyed(PropertyOwner& owner);
+ void ObservedObjectDestroyed(PropertyOwner& owner) override;
public: // PropertyOwner implementation
/**
/**
* @copydoc UniformMapDataProvider::GetUniformMapChanged
*/
- virtual bool GetUniformMapChanged( BufferIndex bufferIndex ) const{ return mUniformMapChanged[bufferIndex];}
+ bool GetUniformMapChanged( BufferIndex bufferIndex ) const override{ return mUniformMapChanged[bufferIndex];}
/**
* @copydoc UniformMapDataProvider::GetUniformMap
*/
- virtual const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const;
+ const CollectedUniformMap& GetUniformMap( BufferIndex bufferIndex ) const override;
void SetDrawCommands( Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size );
/// Messages
inline void SetTexturesMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const TextureSet& textureSet )
{
- typedef MessageValue1< Renderer, TextureSet* > LocalType;
+ using LocalType = MessageValue1<Renderer, TextureSet*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetGeometryMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Render::Geometry& geometry )
{
- typedef MessageValue1< Renderer, Render::Geometry* > LocalType;
+ using LocalType = MessageValue1<Renderer, Render::Geometry*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetShaderMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Shader& shader )
{
- typedef MessageValue1< Renderer, Shader* > LocalType;
+ using LocalType = MessageValue1<Renderer, Shader*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthIndexMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int depthIndex )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetFaceCullingModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, FaceCullingMode::Type faceCullingMode )
{
- typedef MessageValue1< Renderer, FaceCullingMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, FaceCullingMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBlendModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, BlendMode::Type blendingMode )
{
- typedef MessageValue1< Renderer, BlendMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, BlendMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBlendingOptionsMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t options )
{
- typedef MessageValue1< Renderer, uint32_t > LocalType;
+ using LocalType = MessageValue1<Renderer, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetBlendColorMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, const Vector4& blendColor )
{
- typedef MessageValue1< Renderer, Vector4 > LocalType;
+ using LocalType = MessageValue1<Renderer, Vector4>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetIndexedDrawFirstElementMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t firstElement )
{
- typedef MessageValue1< Renderer, uint32_t > LocalType;
+ using LocalType = MessageValue1<Renderer, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetIndexedDrawElementsCountMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, uint32_t elementsCount )
{
- typedef MessageValue1< Renderer, uint32_t > LocalType;
+ using LocalType = MessageValue1<Renderer, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetEnablePreMultipliedAlphaMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, bool preMultiplied )
{
- typedef MessageValue1< Renderer, bool > LocalType;
+ using LocalType = MessageValue1<Renderer, bool>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthWriteModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthWriteMode::Type depthWriteMode )
{
- typedef MessageValue1< Renderer, DepthWriteMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, DepthWriteMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthTestModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthTestMode::Type depthTestMode )
{
- typedef MessageValue1< Renderer, DepthTestMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, DepthTestMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDepthFunctionMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, DepthFunction::Type depthFunction )
{
- typedef MessageValue1< Renderer, DepthFunction::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, DepthFunction::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetRenderModeMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, RenderMode::Type mode )
{
- typedef MessageValue1< Renderer, RenderMode::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, RenderMode::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilFunctionMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilFunction::Type stencilFunction )
{
- typedef MessageValue1< Renderer, StencilFunction::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilFunction::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilFunctionMaskMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int mask )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilFunctionReferenceMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilFunctionReference )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilMaskMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, int stencilMask )
{
- typedef MessageValue1< Renderer, int > LocalType;
+ using LocalType = MessageValue1<Renderer, int>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilOperationOnFailMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation )
{
- typedef MessageValue1< Renderer, StencilOperation::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilOperationOnZFailMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation )
{
- typedef MessageValue1< Renderer, StencilOperation::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetStencilOperationOnZPassMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, StencilOperation::Type stencilOperation )
{
- typedef MessageValue1< Renderer, StencilOperation::Type > LocalType;
+ using LocalType = MessageValue1<Renderer, StencilOperation::Type>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void BakeOpacityMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, float opacity )
{
- typedef MessageDoubleBuffered1< Renderer, float > LocalType;
+ using LocalType = MessageDoubleBuffered1<Renderer, float>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetDrawCommandsMessage( EventThreadServices& eventThreadServices, const Renderer& renderer, Dali::DevelRenderer::DrawCommand* pDrawCommands, uint32_t size )
{
- typedef MessageValue2< Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t > LocalType;
+ using LocalType = MessageValue2<Renderer, Dali::DevelRenderer::DrawCommand*, uint32_t>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
mSamplers.Resize( index + 1 );
for( uint32_t i(samplerCount); i<=index; ++i )
{
- mSamplers[i] = NULL;
+ mSamplers[i] = nullptr;
}
}
for( uint32_t i(textureCount); i<=index; ++i )
{
- mTextures[i] = 0;
+ mTextures[i] = nullptr;
if( !samplerExist )
{
- mSamplers[i] = 0;
+ mSamplers[i] = nullptr;
}
}
}
inline void SetTextureMessage( EventThreadServices& eventThreadServices, const TextureSet& textureSet, uint32_t index, Render::Texture* texture )
{
- typedef MessageValue2< TextureSet, uint32_t, Render::Texture* > LocalType;
+ using LocalType = MessageValue2<TextureSet, uint32_t, Render::Texture*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
inline void SetSamplerMessage( EventThreadServices& eventThreadServices, const TextureSet& textureSet, uint32_t index, Render::Sampler* sampler )
{
- typedef MessageValue2< TextureSet, uint32_t, Render::Sampler* > LocalType;
+ using LocalType = MessageValue2<TextureSet, uint32_t, Render::Sampler*>;
// Reserve some memory inside the message queue
uint32_t* slot = eventThreadServices.ReserveMessageSlot( sizeof( LocalType ) );
#define DALI_ACTOR_ENUMERATIONS_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace Dimension
{
-
/**
* @brief Enumeration for Dimension types.
* @SINCE_1_0.0
*/
enum Type
{
- WIDTH = 0x1, ///< Width dimension @SINCE_1_0.0
- HEIGHT = 0x2, ///< Height dimension @SINCE_1_0.0
+ WIDTH = 0x1, ///< Width dimension @SINCE_1_0.0
+ HEIGHT = 0x2, ///< Height dimension @SINCE_1_0.0
- ALL_DIMENSIONS = 0x3 ///< Mask to cover all flags @SINCE_1_0.0
+ ALL_DIMENSIONS = 0x3 ///< Mask to cover all flags @SINCE_1_0.0
};
/**
*/
enum Meta
{
- DIMENSION_COUNT = 2 ///< Number of dimensions - update this if adding new dimension @SINCE_1_0.0
+ DIMENSION_COUNT = 2 ///< Number of dimensions - update this if adding new dimension @SINCE_1_0.0
};
} // namespace Dimension
*/
namespace ResizePolicy
{
-
/**
* @brief Enumeration for ResizePolicy types.
* @SINCE_1_0.0
*/
enum Type
{
- FIXED, ///< Size is fixed as set by SetSize @SINCE_1_0.0
- USE_NATURAL_SIZE, ///< Size is to use the actor's natural size @SINCE_1_0.0 @see Actor::GetNaturalSize()
- FILL_TO_PARENT, ///< Size is to fill up to the actor's parent's bounds. Aspect ratio is not maintained. @SINCE_1_0.0
- SIZE_RELATIVE_TO_PARENT, ///< The actors size will be ( ParentSize * SizeRelativeToParentFactor ). @SINCE_1_0.0
- SIZE_FIXED_OFFSET_FROM_PARENT, ///< The actors size will be ( ParentSize + SizeRelativeToParentFactor ). @SINCE_1_0.0
- FIT_TO_CHILDREN, ///< Size will adjust to wrap around all children @SINCE_1_0.0
- DIMENSION_DEPENDENCY, ///< One dimension is dependent on the other @SINCE_1_0.0
- USE_ASSIGNED_SIZE ///< The size will be assigned to the actor @SINCE_1_0.0
+ FIXED, ///< Size is fixed as set by SetSize @SINCE_1_0.0
+ USE_NATURAL_SIZE, ///< Size is to use the actor's natural size @SINCE_1_0.0 @see Actor::GetNaturalSize()
+ FILL_TO_PARENT, ///< Size is to fill up to the actor's parent's bounds. Aspect ratio is not maintained. @SINCE_1_0.0
+ SIZE_RELATIVE_TO_PARENT, ///< The actors size will be ( ParentSize * SizeRelativeToParentFactor ). @SINCE_1_0.0
+ SIZE_FIXED_OFFSET_FROM_PARENT, ///< The actors size will be ( ParentSize + SizeRelativeToParentFactor ). @SINCE_1_0.0
+ FIT_TO_CHILDREN, ///< Size will adjust to wrap around all children @SINCE_1_0.0
+ DIMENSION_DEPENDENCY, ///< One dimension is dependent on the other @SINCE_1_0.0
+ USE_ASSIGNED_SIZE ///< The size will be assigned to the actor @SINCE_1_0.0
};
const Type DEFAULT = USE_NATURAL_SIZE; ///< Default resize policy
*/
namespace SizeScalePolicy
{
-
/**
* @brief Enumeration for SizeScalePolicy types.
* @SINCE_1_0.0
*/
enum Type
{
- USE_SIZE_SET, ///< Use the size that was set @SINCE_1_0.0
- FIT_WITH_ASPECT_RATIO, ///< Fit within the size set maintaining natural size aspect ratio @SINCE_1_0.0
- FILL_WITH_ASPECT_RATIO ///< Fill up the size set maintaining natural size aspect ratio. May exceed size bounds in one dimension. @SINCE_1_0.0
+ USE_SIZE_SET, ///< Use the size that was set @SINCE_1_0.0
+ FIT_WITH_ASPECT_RATIO, ///< Fit within the size set maintaining natural size aspect ratio @SINCE_1_0.0
+ FILL_WITH_ASPECT_RATIO ///< Fill up the size set maintaining natural size aspect ratio. May exceed size bounds in one dimension. @SINCE_1_0.0
};
} // namespace SizeScalePolicy
*/
namespace HorizontalAlignment
{
-
/**
* @brief Enumeration for HorizontalAlignment types.
* @SINCE_1_0.0
*/
enum Type
{
- LEFT, ///< Align horizontally left @SINCE_1_0.0
- CENTER, ///< Align horizontally center @SINCE_1_0.0
- RIGHT ///< Align horizontally right @SINCE_1_0.0
+ LEFT, ///< Align horizontally left @SINCE_1_0.0
+ CENTER, ///< Align horizontally center @SINCE_1_0.0
+ RIGHT ///< Align horizontally right @SINCE_1_0.0
};
} // namespace HorizontalAlignment
*/
namespace VerticalAlignment
{
-
/**
* @brief Enumeration for VerticalAlignment types.
* @SINCE_1_0.0
*/
enum Type
{
- TOP, ///< Align vertically top @SINCE_1_0.0
- CENTER, ///< Align vertically center @SINCE_1_0.0
- BOTTOM ///< Align vertically bottom @SINCE_1_0.0
+ TOP, ///< Align vertically top @SINCE_1_0.0
+ CENTER, ///< Align vertically center @SINCE_1_0.0
+ BOTTOM ///< Align vertically bottom @SINCE_1_0.0
};
} // namespace VerticalAlignment
*/
enum Type
{
- DISABLED, ///< This Actor will not clip its children. @SINCE_1_2_5
- CLIP_CHILDREN, ///< This Actor will clip itself and all children to within the pixel areas of this actors renderers. @SINCE_1_2_5
- CLIP_TO_BOUNDING_BOX ///< This Actor will clip itself and all children to within a screen-aligned rectangle encompassing its boundaries. @SINCE_1_2.61
+ DISABLED, ///< This Actor will not clip its children. @SINCE_1_2_5
+ CLIP_CHILDREN, ///< This Actor will clip itself and all children to within the pixel areas of this actors renderers. @SINCE_1_2_5
+ CLIP_TO_BOUNDING_BOX ///< This Actor will clip itself and all children to within a screen-aligned rectangle encompassing its boundaries. @SINCE_1_2.61
};
} // namespace ClippingMode
*/
namespace LayoutDirection
{
-
/**
* @brief Enumeration for the LayoutDirection types.
* @SINCE_1_2.60
*/
enum Type
{
- LEFT_TO_RIGHT, ///< Layout direction is from Left to Right direction. @SINCE_1_2.60
- RIGHT_TO_LEFT ///< Layout direction is from Right to Left direction. @SINCE_1_2.60
+ LEFT_TO_RIGHT, ///< Layout direction is from Left to Right direction. @SINCE_1_2.60
+ RIGHT_TO_LEFT ///< Layout direction is from Right to Left direction. @SINCE_1_2.60
};
} // namespace LayoutDirection
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/actors/layer-impl.h>
-#include <dali/internal/event/rendering/renderer-impl.h>
#include <dali/internal/event/animation/constraint-impl.h>
+#include <dali/internal/event/rendering/renderer-impl.h>
#include <dali/internal/event/size-negotiation/relayout-controller-impl.h>
namespace Dali
{
-
Actor::Actor()
{
}
return Actor(internal.Get());
}
-Actor Actor::DownCast( BaseHandle handle )
+Actor Actor::DownCast(BaseHandle handle)
{
- return Actor( dynamic_cast<Dali::Internal::Actor*>(handle.GetObjectPtr()) );
+ return Actor(dynamic_cast<Dali::Internal::Actor*>(handle.GetObjectPtr()));
}
Actor::~Actor()
Actor& Actor::operator=(const Actor& rhs) = default;
-Actor::Actor( Actor&& rhs ) = default;
+Actor::Actor(Actor&& rhs) = default;
-Actor& Actor::operator=( Actor&& rhs ) = default;
+Actor& Actor::operator=(Actor&& rhs) = default;
Layer Actor::GetLayer()
{
return GetImplementation(*this).GetChildCount();
}
-Actor Actor::GetChildAt( uint32_t index ) const
+Actor Actor::GetChildAt(uint32_t index) const
{
- Internal::ActorPtr child = GetImplementation(*this).GetChildAt( index );
- return Actor( child.Get() );
+ Internal::ActorPtr child = GetImplementation(*this).GetChildAt(index);
+ return Actor(child.Get());
}
Actor Actor::FindChildByName(const std::string& actorName)
{
- Internal::ActorPtr child = GetImplementation(*this).FindChildByName( actorName );
- return Actor( child.Get() );
+ Internal::ActorPtr child = GetImplementation(*this).FindChildByName(actorName);
+ return Actor(child.Get());
}
-Actor Actor::FindChildById( const uint32_t id )
+Actor Actor::FindChildById(const uint32_t id)
{
- Internal::ActorPtr child = GetImplementation(*this).FindChildById( id );
- return Actor( child.Get() );
+ Internal::ActorPtr child = GetImplementation(*this).FindChildById(id);
+ return Actor(child.Get());
}
Actor Actor::GetParent() const
void Actor::Raise()
{
- GetImplementation( *this ).Raise();
+ GetImplementation(*this).Raise();
}
void Actor::Lower()
{
- GetImplementation( *this ).Lower();
+ GetImplementation(*this).Lower();
}
void Actor::RaiseToTop()
{
- GetImplementation( *this ).RaiseToTop();
+ GetImplementation(*this).RaiseToTop();
}
void Actor::LowerToBottom()
{
- GetImplementation( *this ).LowerToBottom();
+ GetImplementation(*this).LowerToBottom();
}
-void Actor::RaiseAbove( Actor target )
+void Actor::RaiseAbove(Actor target)
{
- GetImplementation( *this ).RaiseAbove( GetImplementation( target ) );
+ GetImplementation(*this).RaiseAbove(GetImplementation(target));
}
-void Actor::LowerBelow( Actor target )
+void Actor::LowerBelow(Actor target)
{
- GetImplementation( *this ).LowerBelow( GetImplementation( target ) );
+ GetImplementation(*this).LowerBelow(GetImplementation(target));
}
-void Actor::SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension )
+void Actor::SetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension)
{
- GetImplementation(*this).SetResizePolicy( policy, dimension );
+ GetImplementation(*this).SetResizePolicy(policy, dimension);
}
-ResizePolicy::Type Actor::GetResizePolicy( Dimension::Type dimension ) const
+ResizePolicy::Type Actor::GetResizePolicy(Dimension::Type dimension) const
{
- return GetImplementation(*this).GetResizePolicy( dimension );
+ return GetImplementation(*this).GetResizePolicy(dimension);
}
-float Actor::GetHeightForWidth( float width )
+float Actor::GetHeightForWidth(float width)
{
- return GetImplementation(*this).GetHeightForWidth( width );
+ return GetImplementation(*this).GetHeightForWidth(width);
}
-float Actor::GetWidthForHeight( float height )
+float Actor::GetWidthForHeight(float height)
{
- return GetImplementation(*this).GetWidthForHeight( height );
+ return GetImplementation(*this).GetWidthForHeight(height);
}
-float Actor::GetRelayoutSize( Dimension::Type dimension ) const
+float Actor::GetRelayoutSize(Dimension::Type dimension) const
{
- return GetImplementation(*this).GetRelayoutSize( dimension );
+ return GetImplementation(*this).GetRelayoutSize(dimension);
}
Actor::TouchEventSignalType& Actor::TouchedSignal()
{
- return GetImplementation( *this ).TouchedSignal();
+ return GetImplementation(*this).TouchedSignal();
}
Actor::HoverSignalType& Actor::HoveredSignal()
return GetImplementation(*this).OffSceneSignal();
}
-uint32_t Actor::AddRenderer( Renderer& renderer )
+uint32_t Actor::AddRenderer(Renderer& renderer)
{
- return GetImplementation(*this).AddRenderer( GetImplementation( renderer ) );
+ return GetImplementation(*this).AddRenderer(GetImplementation(renderer));
}
uint32_t Actor::GetRendererCount() const
return GetImplementation(*this).GetRendererCount();
}
-Renderer Actor::GetRendererAt( uint32_t index )
+Renderer Actor::GetRendererAt(uint32_t index)
{
- Internal::RendererPtr renderer = GetImplementation(*this).GetRendererAt( index );
- return Renderer( renderer.Get() );
+ Internal::RendererPtr renderer = GetImplementation(*this).GetRendererAt(index);
+ return Renderer(renderer.Get());
}
-void Actor::RemoveRenderer( Renderer& renderer )
+void Actor::RemoveRenderer(Renderer& renderer)
{
- GetImplementation(*this).RemoveRenderer( GetImplementation( renderer ) );
+ GetImplementation(*this).RemoveRenderer(GetImplementation(renderer));
}
-void Actor::RemoveRenderer( uint32_t index )
+void Actor::RemoveRenderer(uint32_t index)
{
- GetImplementation(*this).RemoveRenderer( index );
+ GetImplementation(*this).RemoveRenderer(index);
}
Actor::OnRelayoutSignalType& Actor::OnRelayoutSignal()
Actor::LayoutDirectionChangedSignalType& Actor::LayoutDirectionChangedSignal()
{
- return GetImplementation( *this ).LayoutDirectionChangedSignal();
+ return GetImplementation(*this).LayoutDirectionChangedSignal();
}
Actor::Actor(Internal::Actor* internal)
*/
// EXTERNAL INCLUDES
-#include <string>
#include <cstdint> // uint32_t
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/actors/actor-enumerations.h>
struct Vector3;
struct Vector4;
-typedef Rect<float> Padding; ///< Padding definition @SINCE_1_0.0
+using Padding = Rect<float>; ///< Padding definition @SINCE_1_0.0
/**
* @brief Actor is the primary object with which Dali applications interact.
class DALI_CORE_API Actor : public Handle
{
public:
-
/**
* @brief Enumeration for the instance of properties belonging to the Actor class.
* @SINCE_1_0.0
// Typedefs
- typedef Signal< bool (Actor, const TouchEvent&) > TouchEventSignalType; ///< Touch signal type @SINCE_1_1.37
- typedef Signal< bool (Actor, const HoverEvent&) > HoverSignalType; ///< Hover signal type @SINCE_1_0.0
- typedef Signal< bool (Actor, const WheelEvent&) > WheelEventSignalType; ///< Wheel signal type @SINCE_1_0.0
- typedef Signal< void (Actor) > OnSceneSignalType; ///< Scene connection signal type @SINCE_1_9.24
- typedef Signal< void (Actor) > OffSceneSignalType; ///< Scene disconnection signal type @SINCE_1_9.24
- typedef Signal< void (Actor) > OnRelayoutSignalType; ///< Called when the actor is relaid out @SINCE_1_0.0
- typedef Signal< void ( Actor, LayoutDirection::Type ) > LayoutDirectionChangedSignalType; ///< Layout direction changes signal type. @SINCE_1_2.60
+ using TouchEventSignalType = Signal<bool(Actor, const TouchEvent&)>; ///< Touch signal type @SINCE_1_1.37
+ using HoverSignalType = Signal<bool(Actor, const HoverEvent&)>; ///< Hover signal type @SINCE_1_0.0
+ using WheelEventSignalType = Signal<bool(Actor, const WheelEvent&)>; ///< Wheel signal type @SINCE_1_0.0
+ using OnSceneSignalType = Signal<void(Actor)>; ///< Scene connection signal type @SINCE_1_9.24
+ using OffSceneSignalType = Signal<void(Actor)>; ///< Scene disconnection signal type @SINCE_1_9.24
+ using OnRelayoutSignalType = Signal<void(Actor)>; ///< Called when the actor is relaid out @SINCE_1_0.0
+ using LayoutDirectionChangedSignalType = Signal<void(Actor, LayoutDirection::Type)>; ///< Layout direction changes signal type. @SINCE_1_2.60
// Creation
* @param[in] handle to An object
* @return handle to a Actor object or an uninitialized handle
*/
- static Actor DownCast( BaseHandle handle );
+ static Actor DownCast(BaseHandle handle);
/**
* @brief Dali::Actor is intended as a base class.
* @SINCE_1_9.22
* @param[in] rhs A reference to the actor to move
*/
- Actor( Actor&& rhs );
+ Actor(Actor&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the actor to move
* @return A reference to this
*/
- Actor& operator=( Actor&& rhs );
+ Actor& operator=(Actor&& rhs);
// Containment
* @return The actor for the given index or empty handle if children not initialized
* @pre The Actor has been initialized.
*/
- Actor GetChildAt( uint32_t index ) const;
+ Actor GetChildAt(uint32_t index) const;
/**
* @brief Search through this actor's hierarchy for an actor with the given name.
* @return A handle to the actor if found, or an empty handle if not
* @pre The Actor has been initialized.
*/
- Actor FindChildById( const uint32_t id );
+ Actor FindChildById(const uint32_t id);
/**
* @brief Retrieves the actor's parent.
* @param[in] axis The axis of the rotation to combine with the existing orientation
* @pre The actor has been initialized.
*/
- void RotateBy( const Degree& angle, const Vector3& axis )
+ void RotateBy(const Degree& angle, const Vector3& axis)
{
- RotateBy( Radian( angle ), axis );
+ RotateBy(Radian(angle), axis);
}
/**
* @pre The Actor has been parented.
* @pre The target actor is a sibling.
*/
- void RaiseAbove( Actor target );
+ void RaiseAbove(Actor target);
/**
* @brief Lower the actor to below the target actor.
* @pre The Actor has been parented.
* @pre The target actor is a sibling.
*/
- void LowerBelow( Actor target );
+ void LowerBelow(Actor target);
// SIZE NEGOTIATION
* @param[in] policy The resize policy to use
* @param[in] dimension The dimension(s) to set policy for. Can be a bitfield of multiple dimensions
*/
- void SetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension );
+ void SetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension);
/**
* @brief Returns the resize policy used for a single dimension.
* @param[in] dimension The dimension to get policy for
* @return Return the dimension resize policy. If more than one dimension is requested, just return the first one found
*/
- ResizePolicy::Type GetResizePolicy( Dimension::Type dimension ) const;
+ ResizePolicy::Type GetResizePolicy(Dimension::Type dimension) const;
/**
* @brief Calculates the height of the actor given a width.
* @param[in] width Width to use
* @return Return the height based on the width
*/
- float GetHeightForWidth( float width );
+ float GetHeightForWidth(float width);
/**
* @brief Calculates the width of the actor given a height.
* @param[in] height Height to use
* @return Return the width based on the height
*/
- float GetWidthForHeight( float height );
+ float GetWidthForHeight(float height);
/**
* @brief Returns the value of negotiated dimension for the given dimension.
* @param[in] dimension The dimension to retrieve
* @return Return the value of the negotiated dimension. If more than one dimension is requested, just return the first one found
*/
- float GetRelayoutSize( Dimension::Type dimension ) const;
+ float GetRelayoutSize(Dimension::Type dimension) const;
public: // Renderer
-
/**
* @brief Adds a renderer to this actor.
*
* @pre The renderer must be initialized.
*
*/
- uint32_t AddRenderer( Renderer& renderer );
+ uint32_t AddRenderer(Renderer& renderer);
/**
* @brief Gets the number of renderers on this actor.
* @pre The index must be between 0 and GetRendererCount()-1
*
*/
- Renderer GetRendererAt( uint32_t index );
+ Renderer GetRendererAt(uint32_t index);
/**
* @brief Removes a renderer from the actor.
* @SINCE_1_0.0
* @param[in] renderer Handle to the renderer that is to be removed
*/
- void RemoveRenderer( Renderer& renderer );
+ void RemoveRenderer(Renderer& renderer);
/**
* @brief Removes a renderer from the actor by index.
* @pre The index must be between 0 and GetRendererCount()-1
*
*/
- void RemoveRenderer( uint32_t index );
+ void RemoveRenderer(uint32_t index);
public: // Signals
-
/**
* @brief This signal is emitted when touch input is received.
*
LayoutDirectionChangedSignalType& LayoutDirectionChangedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Actor::New() methods.
* @SINCE_1_0.0
* @param[in,out] actor A handle to an actor, or an empty handle
*/
-inline void UnparentAndReset( Actor& actor )
+inline void UnparentAndReset(Actor& actor)
{
- if( actor )
+ if(actor)
{
actor.Unparent();
actor.Reset();
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
CameraActor CameraActor::New()
{
- Internal::CameraActorPtr internal = Internal::CameraActor::New( Size::ZERO );
+ Internal::CameraActorPtr internal = Internal::CameraActor::New(Size::ZERO);
return CameraActor(internal.Get());
}
-
-CameraActor CameraActor::New( const Size& size )
+CameraActor CameraActor::New(const Size& size)
{
- Internal::CameraActorPtr internal = Internal::CameraActor::New( size );
+ Internal::CameraActorPtr internal = Internal::CameraActor::New(size);
return CameraActor(internal.Get());
}
{
}
-CameraActor CameraActor::DownCast( BaseHandle handle )
+CameraActor CameraActor::DownCast(BaseHandle handle)
{
- return CameraActor( dynamic_cast<Dali::Internal::CameraActor*>(handle.GetObjectPtr()) );
+ return CameraActor(dynamic_cast<Dali::Internal::CameraActor*>(handle.GetObjectPtr()));
}
CameraActor::CameraActor()
return *this;
}
-void CameraActor::SetType( Dali::Camera::Type type )
+void CameraActor::SetType(Dali::Camera::Type type)
{
GetImplementation(*this).SetType(type);
}
return GetImplementation(*this).GetType();
}
-void CameraActor::SetProjectionMode( Dali::Camera::ProjectionMode mode )
+void CameraActor::SetProjectionMode(Dali::Camera::ProjectionMode mode)
{
- GetImplementation(*this).SetProjectionMode( mode );
+ GetImplementation(*this).SetProjectionMode(mode);
}
Dali::Camera::ProjectionMode CameraActor::GetProjectionMode() const
return GetImplementation(*this).GetProjectionMode();
}
-void CameraActor::SetFieldOfView( float fieldOfView )
+void CameraActor::SetFieldOfView(float fieldOfView)
{
GetImplementation(*this).SetFieldOfView(fieldOfView);
}
-float CameraActor::GetFieldOfView( )
+float CameraActor::GetFieldOfView()
{
return GetImplementation(*this).GetFieldOfView();
}
-void CameraActor::SetAspectRatio( float aspectRatio )
+void CameraActor::SetAspectRatio(float aspectRatio)
{
GetImplementation(*this).SetAspectRatio(aspectRatio);
}
-float CameraActor::GetAspectRatio( )
+float CameraActor::GetAspectRatio()
{
return GetImplementation(*this).GetAspectRatio();
}
-void CameraActor::SetNearClippingPlane( float nearClippingPlane )
+void CameraActor::SetNearClippingPlane(float nearClippingPlane)
{
GetImplementation(*this).SetNearClippingPlane(nearClippingPlane);
}
-float CameraActor::GetNearClippingPlane( )
+float CameraActor::GetNearClippingPlane()
{
return GetImplementation(*this).GetNearClippingPlane();
}
-void CameraActor::SetFarClippingPlane( float farClippingPlane )
+void CameraActor::SetFarClippingPlane(float farClippingPlane)
{
GetImplementation(*this).SetFarClippingPlane(farClippingPlane);
}
-float CameraActor::GetFarClippingPlane( )
+float CameraActor::GetFarClippingPlane()
{
return GetImplementation(*this).GetFarClippingPlane();
}
-void CameraActor::SetTargetPosition( const Vector3& targetPosition )
+void CameraActor::SetTargetPosition(const Vector3& targetPosition)
{
GetImplementation(*this).SetTarget(targetPosition);
}
return GetImplementation(*this).GetInvertYAxis();
}
-void CameraActor::SetPerspectiveProjection( const Size& size )
+void CameraActor::SetPerspectiveProjection(const Size& size)
{
- GetImplementation(*this).SetPerspectiveProjection( size );
+ GetImplementation(*this).SetPerspectiveProjection(size);
}
-void CameraActor::SetOrthographicProjection( const Vector2& size )
+void CameraActor::SetOrthographicProjection(const Vector2& size)
{
- GetImplementation(*this).SetOrthographicProjection( size );
+ GetImplementation(*this).SetOrthographicProjection(size);
}
-void CameraActor::SetOrthographicProjection( float left, float right, float top, float bottom, float near, float far )
+void CameraActor::SetOrthographicProjection(float left, float right, float top, float bottom, float near, float far)
{
- GetImplementation(*this).SetOrthographicProjection( left, right, top, bottom, near, far );
+ GetImplementation(*this).SetOrthographicProjection(left, right, top, bottom, near, far);
}
} // namespace Dali
#define DALI_CAMERA_ACTOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
enum ProjectionMode
{
- PERSPECTIVE_PROJECTION, ///< Distance causes foreshortening; objects further from the camera appear smaller @SINCE_1_0.0
- ORTHOGRAPHIC_PROJECTION, ///< Relative distance from the camera does not affect the size of objects @SINCE_1_0.0
+ PERSPECTIVE_PROJECTION, ///< Distance causes foreshortening; objects further from the camera appear smaller @SINCE_1_0.0
+ ORTHOGRAPHIC_PROJECTION, ///< Relative distance from the camera does not affect the size of objects @SINCE_1_0.0
};
} // namespace Camera
class DALI_CORE_API CameraActor : public Actor
{
public:
-
/**
* @brief Enumeration for the instance of properties belonging to the CameraActor class.
*
* @param[in] size The canvas size
* @return The newly created camera actor
*/
- static CameraActor New( const Size& size );
+ static CameraActor New(const Size& size);
/**
* @brief Downcasts a handle to CameraActor handle.
* @param[in] handle to An object
* @return Handle to a CameraActor or an uninitialized handle
*/
- static CameraActor DownCast( BaseHandle handle );
+ static CameraActor DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_0.0
* @param[in] type The camera type
*/
- void SetType( Dali::Camera::Type type );
+ void SetType(Dali::Camera::Type type);
/**
* @brief Gets the type of the camera.
* @SINCE_1_0.0
* @param[in] mode One of PERSPECTIVE_PROJECTION or ORTHOGRAPHIC_PROJECTION
*/
- void SetProjectionMode( Dali::Camera::ProjectionMode mode );
+ void SetProjectionMode(Dali::Camera::ProjectionMode mode);
/**
* @brief Gets the projection mode.
* @SINCE_1_0.0
* @param[in] fieldOfView The field of view in radians
*/
- void SetFieldOfView( float fieldOfView );
+ void SetFieldOfView(float fieldOfView);
/**
* @brief Gets the field of view in Radians.
* @SINCE_1_0.0
* @return The field of view in radians
*/
- float GetFieldOfView( );
+ float GetFieldOfView();
/**
* @brief Sets the aspect ratio.
* @SINCE_1_0.0
* @param[in] aspectRatio The aspect ratio
*/
- void SetAspectRatio( float aspectRatio );
+ void SetAspectRatio(float aspectRatio);
/**
* @brief Gets the aspect ratio of the camera.
* @SINCE_1_0.0
* @return The aspect ratio
*/
- float GetAspectRatio( );
+ float GetAspectRatio();
/**
* @brief Sets the near clipping plane distance.
* @SINCE_1_0.0
* @param[in] nearClippingPlane Distance of the near clipping plane
*/
- void SetNearClippingPlane( float nearClippingPlane );
+ void SetNearClippingPlane(float nearClippingPlane);
/**
* @brief Gets the near clipping plane distance.
* @SINCE_1_0.0
* @return The near clipping plane value
*/
- float GetNearClippingPlane( );
+ float GetNearClippingPlane();
/**
* @brief Sets the far clipping plane distance.
* @SINCE_1_0.0
* @param[in] farClippingPlane Distance of the far clipping plane
*/
- void SetFarClippingPlane( float farClippingPlane );
+ void SetFarClippingPlane(float farClippingPlane);
/**
* @brief Gets the far clipping plane distance.
* @SINCE_1_0.0
* @return The far clipping plane value
*/
- float GetFarClippingPlane( );
+ float GetFarClippingPlane();
/**
* @brief Sets the target position of the camera.
* @param[in] targetPosition The position of the target to look at
* @pre Camera type is LOOK_AT_TARGET.
*/
- void SetTargetPosition( const Vector3& targetPosition );
+ void SetTargetPosition(const Vector3& targetPosition);
/**
* @brief Gets the Camera Target position.
* @note If either of the values of size is 0.0f, then we use the default perspective projection for the size of the scene this actor is added to.
* @note This modifies the Z position property of this actor as well.
*/
- void SetPerspectiveProjection( const Size& size );
+ void SetPerspectiveProjection(const Size& size);
/**
* @brief Sets the camera projection to use orthographic projection.
* @SINCE_1_0.0
* @param[in] size Size of XY plane (normal to camera axis)
*/
- void SetOrthographicProjection( const Size& size );
+ void SetOrthographicProjection(const Size& size);
/**
* @brief Sets the camera projection to use orthographic projection with the given clip planes.
* @param[in] near Distance to the near clip plane (along camera axis)
* @param[in] far Distance to the far clip plane (along camera axis)
*/
- void SetOrthographicProjection( float left, float right, float top, float bottom, float near, float far );
+ void SetOrthographicProjection(float left, float right, float top, float bottom, float near, float far);
public: // Not intended for use by Application developers
/// @cond internal
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/actors/custom-actor-impl.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/internal/event/actors/custom-actor-internal.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
CustomActor CustomActorImpl::Self() const
{
return CustomActor(mOwner);
}
-void CustomActorImpl::OnPropertySet( Property::Index index, const Property::Value& propertyValue )
+void CustomActorImpl::OnPropertySet(Property::Index index, const Property::Value& propertyValue)
{
}
-CustomActorImpl::CustomActorImpl( ActorFlags flags )
-: mOwner(NULL),
- mFlags( flags )
+CustomActorImpl::CustomActorImpl(ActorFlags flags)
+: mOwner(nullptr),
+ mFlags(flags)
{
}
bool CustomActorImpl::IsRelayoutEnabled() const
{
- return ( mFlags & DISABLE_SIZE_NEGOTIATION ) == 0;
+ return (mFlags & DISABLE_SIZE_NEGOTIATION) == 0;
}
void CustomActorImpl::RelayoutRequest()
mOwner->RelayoutRequest();
}
-float CustomActorImpl::GetHeightForWidthBase( float width )
+float CustomActorImpl::GetHeightForWidthBase(float width)
{
- return mOwner->GetHeightForWidthBase( width );
+ return mOwner->GetHeightForWidthBase(width);
}
-float CustomActorImpl::GetWidthForHeightBase( float height )
+float CustomActorImpl::GetWidthForHeightBase(float height)
{
- return mOwner->GetWidthForHeightBase( height );
+ return mOwner->GetWidthForHeightBase(height);
}
-float CustomActorImpl::CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension )
+float CustomActorImpl::CalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension)
{
- return mOwner->CalculateChildSizeBase( child, dimension );
+ return mOwner->CalculateChildSizeBase(child, dimension);
}
-bool CustomActorImpl::RelayoutDependentOnChildrenBase( Dimension::Type dimension )
+bool CustomActorImpl::RelayoutDependentOnChildrenBase(Dimension::Type dimension)
{
- return mOwner->RelayoutDependentOnChildrenBase( dimension );
+ return mOwner->RelayoutDependentOnChildrenBase(dimension);
}
} // namespace Dali
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
-#include <dali/public-api/object/property.h>
-#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/actors/actor-enumerations.h>
#include <dali/public-api/math/compile-time-math.h>
+#include <dali/public-api/object/property.h>
+#include <dali/public-api/object/ref-object.h>
namespace Dali
{
* @brief Pointer to Dali::CustomActorImpl object.
* @SINCE_1_0.0
*/
-typedef IntrusivePtr<CustomActorImpl> CustomActorImplPtr;
+using CustomActorImplPtr = IntrusivePtr<CustomActorImpl>;
/**
* @brief CustomActorImpl is an abstract base class for custom control implementations.
class DALI_CORE_API CustomActorImpl : public Dali::RefObject
{
public:
-
class Extension; ///< Forward declare future extension interface
protected:
* @brief Virtual destructor
* @SINCE_1_0.0
*/
- virtual ~CustomActorImpl();
+ ~CustomActorImpl() override;
public:
/**
* @endcode
* @param[in] depth The depth in the hierarchy for the actor
*/
- virtual void OnSceneConnection( int32_t depth ) = 0;
+ virtual void OnSceneConnection(int32_t depth) = 0;
/**
* @brief Called after the actor has been disconnected from the Scene.
* @param[in] index The Property index that was set
* @param[in] propertyValue The value to set
*/
- virtual void OnPropertySet( Property::Index index, const Property::Value& propertyValue );
+ virtual void OnPropertySet(Property::Index index, const Property::Value& propertyValue);
/**
* @brief Called when the owning actor's size is set e.g. using Actor::SetSize().
* @note As this function is called from inside the size negotiation algorithm, you cannot
* call RequestRelayout (the call would just be ignored).
*/
- virtual void OnRelayout( const Vector2& size, RelayoutContainer& container ) = 0;
+ virtual void OnRelayout(const Vector2& size, RelayoutContainer& container) = 0;
/**
* @brief Notification for deriving classes.
* @param[in] policy The policy being set
* @param[in] dimension The dimension the policy is being set for
*/
- virtual void OnSetResizePolicy( ResizePolicy::Type policy, Dimension::Type dimension ) = 0;
+ virtual void OnSetResizePolicy(ResizePolicy::Type policy, Dimension::Type dimension) = 0;
/**
* @brief Returns the natural size of the actor.
* @param[in] dimension The dimension to calculate the size for. E.g. width or height
* @return Return the calculated size for the given dimension
*/
- virtual float CalculateChildSize( const Dali::Actor& child, Dimension::Type dimension ) = 0;
+ virtual float CalculateChildSize(const Dali::Actor& child, Dimension::Type dimension) = 0;
/**
* @brief This method is called during size negotiation when a height is required for a given width.
* @param[in] width Width to use
* @return The height based on the width
*/
- virtual float GetHeightForWidth( float width ) = 0;
+ virtual float GetHeightForWidth(float width) = 0;
/**
* @brief This method is called during size negotiation when a width is required for a given height.
* @param[in] height Height to use
* @return The width based on the width
*/
- virtual float GetWidthForHeight( float height ) = 0;
+ virtual float GetWidthForHeight(float height) = 0;
/**
* @brief Determines if this actor is dependent on its children for relayout.
* @param[in] dimension The dimension(s) to check for
* @return Return if the actor is dependent on it's children
*/
- virtual bool RelayoutDependentOnChildren( Dimension::Type dimension = Dimension::ALL_DIMENSIONS ) = 0;
+ virtual bool RelayoutDependentOnChildren(Dimension::Type dimension = Dimension::ALL_DIMENSIONS) = 0;
/**
* @brief Virtual method to notify deriving classes that relayout dependencies have been
* @SINCE_1_0.0
* @param[in] dimension The dimension that is about to be calculated
*/
- virtual void OnCalculateRelayoutSize( Dimension::Type dimension ) = 0;
+ virtual void OnCalculateRelayoutSize(Dimension::Type dimension) = 0;
/**
* @brief Virtual method to notify deriving classes that the size for a dimension
* @param[in] size The new size for the given dimension
* @param[in] dimension The dimension that was just negotiated
*/
- virtual void OnLayoutNegotiated( float size, Dimension::Type dimension ) = 0;
+ virtual void OnLayoutNegotiated(float size, Dimension::Type dimension) = 0;
/**
* @brief Retrieves the extension for this control.
*/
virtual Extension* GetExtension()
{
- return NULL;
+ return nullptr;
}
protected: // For derived classes
-
/**
* @brief Enumeration for the constructor flags.
* @SINCE_1_0.0
*/
enum ActorFlags
{
- ACTOR_BEHAVIOUR_DEFAULT = 0, ///< Use to provide default behaviour (size negotiation is on, event callbacks are not called). @SINCE_1_2_10
- DISABLE_SIZE_NEGOTIATION = 1 << 0, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm @SINCE_1_0.0
+ ACTOR_BEHAVIOUR_DEFAULT = 0, ///< Use to provide default behaviour (size negotiation is on, event callbacks are not called). @SINCE_1_2_10
+ DISABLE_SIZE_NEGOTIATION = 1 << 0, ///< True if control does not need size negotiation, i.e. it can be skipped in the algorithm @SINCE_1_0.0
- LAST_ACTOR_FLAG ///< Special marker for last actor flag @SINCE_1_0.0
+ LAST_ACTOR_FLAG ///< Special marker for last actor flag @SINCE_1_0.0
};
- static constexpr int32_t ACTOR_FLAG_COUNT = Log< LAST_ACTOR_FLAG - 1 >::value + 1; ///< Value for deriving classes to continue on the flag enum
+ static constexpr int32_t ACTOR_FLAG_COUNT = Log<LAST_ACTOR_FLAG - 1>::value + 1; ///< Value for deriving classes to continue on the flag enum
/**
* @brief Creates a CustomActorImpl.
* @SINCE_1_0.0
* @param[in] flags Bitfield of ActorFlags to define behaviour
*/
- CustomActorImpl( ActorFlags flags );
+ CustomActorImpl(ActorFlags flags);
// Size negotiation helpers
* @param[in] width Width to use
* @return The height based on the width
*/
- float GetHeightForWidthBase( float width );
+ float GetHeightForWidthBase(float width);
/**
* @brief Provides the Actor implementation of GetWidthForHeight.
* @param[in] height Height to use
* @return The width based on the height
*/
- float GetWidthForHeightBase( float height );
+ float GetWidthForHeightBase(float height);
/**
* @brief Calculates the size for a child using the base actor object.
* @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
*/
- float CalculateChildSizeBase( const Dali::Actor& child, Dimension::Type dimension );
+ float CalculateChildSizeBase(const Dali::Actor& child, Dimension::Type dimension);
/**
* @brief Determines if this actor is dependent on its children for relayout from the base class.
* @param[in] dimension The dimension(s) to check for
* @return Return if the actor is dependent on it's children
*/
- bool RelayoutDependentOnChildrenBase( Dimension::Type dimension = Dimension::ALL_DIMENSIONS );
+ bool RelayoutDependentOnChildrenBase(Dimension::Type dimension = Dimension::ALL_DIMENSIONS);
public: // Not intended for application developers
-
/**
* @brief Initializes a CustomActor.
* @SINCE_1_0.0
bool IsRelayoutEnabled() const;
private:
-
- Internal::CustomActor* mOwner; ///< Internal owner of this custom actor implementation
- ActorFlags mFlags; ///< ActorFlags flags to determine behaviour
+ Internal::CustomActor* mOwner; ///< Internal owner of this custom actor implementation
+ ActorFlags mFlags; ///< ActorFlags flags to determine behaviour
};
/**
namespace Dali
{
-
namespace
{
-
using namespace Dali;
BaseHandle Create()
return BaseHandle();
}
-TypeRegistration mType( typeid(Dali::CustomActor), typeid(Dali::Actor), Create );
+TypeRegistration mType(typeid(Dali::CustomActor), typeid(Dali::Actor), Create);
-}
+} // namespace
CustomActor::CustomActor()
{
}
-CustomActor CustomActor::DownCast( BaseHandle handle )
+CustomActor CustomActor::DownCast(BaseHandle handle)
{
- return CustomActor( dynamic_cast<Dali::Internal::CustomActor*>(handle.GetObjectPtr()) );
+ return CustomActor(dynamic_cast<Dali::Internal::CustomActor*>(handle.GetObjectPtr()));
}
CustomActor::~CustomActor()
CustomActor& CustomActor::operator=(const CustomActor& rhs) = default;
-CustomActor::CustomActor( CustomActor&& rhs ) = default;
+CustomActor::CustomActor(CustomActor&& rhs) = default;
-CustomActor& CustomActor::operator=( CustomActor&& rhs ) = default;
+CustomActor& CustomActor::operator=(CustomActor&& rhs) = default;
CustomActorImpl& CustomActor::GetImplementation()
{
// Without this check, the actor will be deleted a second time, when the handle is disposed of
// causing a crash.
- if (internal)
+ if(internal)
{
DALI_ASSERT_ALWAYS(internal->ReferenceCount() != 1 && "Are you trying to use CustomActorImpl::Self() inside a CustomActorImpl destructor?");
}
class DALI_CORE_API CustomActor : public Actor
{
public:
-
/**
* @brief Creates an uninitialized CustomActor handle.
*
* @param[in] handle Handle to an object
* @return Handle to a CustomActor or an uninitialized handle
*/
- static CustomActor DownCast( BaseHandle handle );
+ static CustomActor DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_9.22
* @param[in] rhs The actor to move
*/
- CustomActor( CustomActor&& rhs );
+ CustomActor(CustomActor&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs The actor to move
* @return A reference to this
*/
- CustomActor& operator=( CustomActor&& rhs );
+ CustomActor& operator=(CustomActor&& rhs);
public: // Not intended for application developers
-
/**
* @brief This constructor is used internally to create additional CustomActor handles.
*
#define DALI_DRAW_MODE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace DrawMode
{
-
/**
* @brief Enumeration for the instance of how the actor and it's children will be drawn.
*
namespace Dali
{
-
using Dali::Layer;
Layer::Layer()
return Layer(internal.Get());
}
-Layer Layer::DownCast( BaseHandle handle )
+Layer Layer::DownCast(BaseHandle handle)
{
- return Layer( dynamic_cast<Dali::Internal::Layer*>(handle.GetObjectPtr()) );
+ return Layer(dynamic_cast<Dali::Internal::Layer*>(handle.GetObjectPtr()));
}
Layer::~Layer()
Layer& Layer::operator=(const Layer& rhs) = default;
-Layer::Layer( Layer&& rhs ) = default;
+Layer::Layer(Layer&& rhs) = default;
-Layer& Layer::operator=( Layer&& rhs ) = default;
+Layer& Layer::operator=(Layer&& rhs) = default;
void Layer::Raise()
{
GetImplementation(*this).Lower();
}
-void Layer::RaiseAbove( Layer target )
+void Layer::RaiseAbove(Layer target)
{
- GetImplementation(*this).RaiseAbove( GetImplementation( target ) );
+ GetImplementation(*this).RaiseAbove(GetImplementation(target));
}
-void Layer::LowerBelow( Layer target )
+void Layer::LowerBelow(Layer target)
{
- GetImplementation(*this).LowerBelow( GetImplementation( target ) );
+ GetImplementation(*this).LowerBelow(GetImplementation(target));
}
void Layer::RaiseToTop()
GetImplementation(*this).LowerToBottom();
}
-void Layer::MoveAbove( Layer target )
+void Layer::MoveAbove(Layer target)
{
- GetImplementation(*this).MoveAbove( GetImplementation( target ) );
+ GetImplementation(*this).MoveAbove(GetImplementation(target));
}
-void Layer::MoveBelow( Layer target )
+void Layer::MoveBelow(Layer target)
{
- GetImplementation(*this).MoveBelow( GetImplementation( target ) );
+ GetImplementation(*this).MoveBelow(GetImplementation(target));
}
void Layer::SetSortFunction(SortFunctionType function)
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
-#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/actors/actor.h>
#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/vector3.h>
+#include <dali/public-api/object/ref-object.h>
namespace Dali
{
* @SINCE_1_0.0
* @see Dali::Layer::SetClippingBox()
*/
-typedef Rect<int32_t> ClippingBox;
+using ClippingBox = Rect<int32_t>;
/**
* @brief Layers provide a mechanism for overlaying groups of actors on top of each other.
class DALI_CORE_API Layer : public Actor
{
public:
-
/**
* @brief Enumeration for the instance of properties belonging to the Layer class.
*
* @SINCE_1_0.0
* @param[in] position This is the actor translation from camera
*/
- typedef float (*SortFunctionType)( const Vector3& position );
+ using SortFunctionType = float (*)(const Vector3&);
/**
* @brief Creates an empty Layer handle.
* @param[in] handle Handle to an object
* @return Handle to a Layer or an uninitialized handle
*/
- static Layer DownCast( BaseHandle handle );
+ static Layer DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_9.22
* @param[in] rhs The layer to move
*/
- Layer( Layer&& rhs );
+ Layer(Layer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs The layer to move
* @return A reference to this
*/
- Layer& operator=( Layer&& rhs );
+ Layer& operator=(Layer&& rhs);
/**
* @brief Increments the depth of the layer.
* @pre Target layer is on the stage.
* @note All layers between this layer and target get new depth values.
*/
- void RaiseAbove( Layer target );
+ void RaiseAbove(Layer target);
/**
* @brief Ensures the layers depth is less than the target layer.
* @pre Target layer is on the stage.
* @note All layers between this layer and target get new depth values.
*/
- void LowerBelow( Layer target );
+ void LowerBelow(Layer target);
/**
* @brief Raises the layer to the top.
* @pre Target layer is on the stage.
* @note All layers between this layer and target get new depth values.
*/
- void MoveAbove( Layer target );
+ void MoveAbove(Layer target);
/**
* @brief Moves the layer directly below the given layer.
* @pre Target layer is on the stage.
* @note All layers between this layer and target get new depth values.
*/
- void MoveBelow( Layer target );
+ void MoveBelow(Layer target);
// Sorting
* layer, then the sort function used by the child layer will also be the same.
*
*/
- void SetSortFunction( SortFunctionType function );
+ void SetSortFunction(SortFunctionType function);
/**
* @brief Retrieves whether the layer consumes hover.
bool IsHoverConsumed() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Layer::New() methods.
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace
{
-constexpr uint32_t BitMaskOfN( uint32_t bits )
+constexpr uint32_t BitMaskOfN(uint32_t bits)
{
- return ( 1 << bits ) - 1;
+ return (1 << bits) - 1;
}
} // unnamed namespace
AlphaFunction::AlphaFunction()
-:mBezierControlPoints(Vector4::ZERO),
- mCustom(0),
- mBuiltin(DEFAULT),
- mMode(BUILTIN_FUNCTION)
-{}
+: mBezierControlPoints(Vector4::ZERO),
+ mCustom(nullptr),
+ mBuiltin(DEFAULT),
+ mMode(BUILTIN_FUNCTION)
+{
+}
-AlphaFunction::AlphaFunction( BuiltinFunction function)
-:mBezierControlPoints(Vector4::ZERO),
- mCustom(0),
- mBuiltin(function),
- mMode(BUILTIN_FUNCTION)
-{}
+AlphaFunction::AlphaFunction(BuiltinFunction function)
+: mBezierControlPoints(Vector4::ZERO),
+ mCustom(nullptr),
+ mBuiltin(function),
+ mMode(BUILTIN_FUNCTION)
+{
+}
-AlphaFunction::AlphaFunction( AlphaFunctionPrototype function)
-:mBezierControlPoints(Vector4::ZERO),
- mCustom(function),
- mBuiltin(DEFAULT),
- mMode(CUSTOM_FUNCTION)
-{}
+AlphaFunction::AlphaFunction(AlphaFunctionPrototype function)
+: mBezierControlPoints(Vector4::ZERO),
+ mCustom(function),
+ mBuiltin(DEFAULT),
+ mMode(CUSTOM_FUNCTION)
+{
+}
-AlphaFunction::AlphaFunction( const Vector2& controlPoint0, const Vector2& controlPoint1 )
-:mBezierControlPoints(Vector4(Clamp(controlPoint0.x,0.0f,1.0f),controlPoint0.y,
- Clamp(controlPoint1.x,0.0f,1.0f),controlPoint1.y)),
- mCustom(0),
- mBuiltin(DEFAULT),
- mMode(BEZIER)
+AlphaFunction::AlphaFunction(const Vector2& controlPoint0, const Vector2& controlPoint1)
+: mBezierControlPoints(
+ Vector4(Clamp(controlPoint0.x, 0.0f, 1.0f),
+ controlPoint0.y,
+ Clamp(controlPoint1.x, 0.0f, 1.0f),
+ controlPoint1.y)),
+ mCustom(nullptr),
+ mBuiltin(DEFAULT),
+ mMode(BEZIER)
{
}
AlphaFunction::BuiltinFunction AlphaFunction::GetBuiltinFunction() const
{
- return static_cast<AlphaFunction::BuiltinFunction>( mBuiltin & BitMaskOfN( Log<COUNT>::value + 1 ) );
+ return static_cast<AlphaFunction::BuiltinFunction>(mBuiltin & BitMaskOfN(Log<COUNT>::value + 1));
}
AlphaFunction::Mode AlphaFunction::GetMode() const
{
- return static_cast<AlphaFunction::Mode>( mMode & BitMaskOfN( 2 ) );
+ return static_cast<AlphaFunction::Mode>(mMode & BitMaskOfN(2));
}
} // namespace Dali
#define DALI_ALPHA_FUNCTION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
+#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/math/compile-time-math.h>
#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/math/vector2.h>
* @{
*/
-typedef float (*AlphaFunctionPrototype)(float progress); ///< Prototype of an alpha function @SINCE_1_0.0
+using AlphaFunctionPrototype = float (*)(float); ///< Prototype of an alpha function @SINCE_1_0.0
- /**
+/**
* @brief Alpha functions are used in animations to specify the rate of change of the animation parameter over time.
*
* Understanding an animation as a parametric function over time, the alpha function is applied to the parameter of
class DALI_CORE_API AlphaFunction
{
public:
-
/**
* @brief Enumeration for built-in alpha functions.
* @SINCE_1_0.0
*/
enum BuiltinFunction
{
- DEFAULT, ///< Linear @SINCE_1_0.0
- LINEAR, ///< No transformation @SINCE_1_0.0
- REVERSE, ///< Reverse linear @SINCE_1_0.0
-
- EASE_IN_SQUARE, ///< Speeds up and comes to a sudden stop (Square) @SINCE_1_0.0
- EASE_OUT_SQUARE, ///< Sudden start and slows to a gradual stop (Square) @SINCE_1_0.0
-
- EASE_IN, ///< Speeds up and comes to a sudden stop (Cubic) @SINCE_1_0.0
- EASE_OUT, ///< Sudden start and slows to a gradual stop (Cubic) @SINCE_1_0.0
- EASE_IN_OUT, ///< Speeds up and slows to a gradual stop (Cubic) @SINCE_1_0.0
-
- EASE_IN_SINE, ///< Speeds up and comes to a sudden stop (sinusoidal) @SINCE_1_0.0
- EASE_OUT_SINE, ///< Sudden start and slows to a gradual stop (sinusoidal) @SINCE_1_0.0
- EASE_IN_OUT_SINE, ///< Speeds up and slows to a gradual stop (sinusoidal) @SINCE_1_0.0
-
- BOUNCE, ///< Sudden start, loses momentum and returns to start position @SINCE_1_0.0
- SIN, ///< Single revolution @SINCE_1_0.0
- EASE_OUT_BACK, ///< Sudden start, exceed end position and return to a gradual stop @SINCE_1_0.0
-
+ DEFAULT, ///< Linear @SINCE_1_0.0
+ LINEAR, ///< No transformation @SINCE_1_0.0
+ REVERSE, ///< Reverse linear @SINCE_1_0.0
+ EASE_IN_SQUARE, ///< Speeds up and comes to a sudden stop (Square) @SINCE_1_0.0
+ EASE_OUT_SQUARE, ///< Sudden start and slows to a gradual stop (Square) @SINCE_1_0.0
+ EASE_IN, ///< Speeds up and comes to a sudden stop (Cubic) @SINCE_1_0.0
+ EASE_OUT, ///< Sudden start and slows to a gradual stop (Cubic) @SINCE_1_0.0
+ EASE_IN_OUT, ///< Speeds up and slows to a gradual stop (Cubic) @SINCE_1_0.0
+ EASE_IN_SINE, ///< Speeds up and comes to a sudden stop (sinusoidal) @SINCE_1_0.0
+ EASE_OUT_SINE, ///< Sudden start and slows to a gradual stop (sinusoidal) @SINCE_1_0.0
+ EASE_IN_OUT_SINE, ///< Speeds up and slows to a gradual stop (sinusoidal) @SINCE_1_0.0
+ BOUNCE, ///< Sudden start, loses momentum and returns to start position @SINCE_1_0.0
+ SIN, ///< Single revolution @SINCE_1_0.0
+ EASE_OUT_BACK, ///< Sudden start, exceed end position and return to a gradual stop @SINCE_1_0.0
COUNT
};
*/
enum Mode
{
- BUILTIN_FUNCTION, ///< The user has specified a built-in function @SINCE_1_0.0
- CUSTOM_FUNCTION, ///< The user has provided a custom function @SINCE_1_0.0
- BEZIER ///< The user has provided the control points of a bezier curve @SINCE_1_0.0
+ BUILTIN_FUNCTION, ///< The user has specified a built-in function @SINCE_1_0.0
+ CUSTOM_FUNCTION, ///< The user has provided a custom function @SINCE_1_0.0
+ BEZIER ///< The user has provided the control points of a bezier curve @SINCE_1_0.0
};
/**
* @param[in] function One of the built-in alpha functions
* @return The alpha function
*/
- AlphaFunction( BuiltinFunction function);
+ AlphaFunction(BuiltinFunction function);
/**
* @brief Constructor.
* @param[in] function A pointer to an alpha function
* @return The alpha function
*/
- AlphaFunction( AlphaFunctionPrototype function);
+ AlphaFunction(AlphaFunctionPrototype function);
/**
* @brief Constructor.
* @note The x components of the control points will be clamped to the range [0,1] to prevent
* non monotonic curves.
*/
- AlphaFunction( const Dali::Vector2& controlPoint0, const Dali::Vector2& controlPoint1 );
+ AlphaFunction(const Dali::Vector2& controlPoint0, const Dali::Vector2& controlPoint1);
/**
* @brief Returns the control points of the alpha function.
Mode GetMode() const;
private:
-
- Vector4 mBezierControlPoints; //< Control points for the bezier alpha function
- AlphaFunctionPrototype mCustom; //< Pointer to an alpha function
- BuiltinFunction mBuiltin : Log<COUNT>::value+1; //< Enum indicating the built-in alpha function
- Mode mMode : 2; //< Enum indicating the functioning mode of the AlphaFunction
+ Vector4 mBezierControlPoints; //< Control points for the bezier alpha function
+ AlphaFunctionPrototype mCustom; //< Pointer to an alpha function
+ BuiltinFunction mBuiltin : Log<COUNT>::value + 1; //< Enum indicating the built-in alpha function
+ Mode mMode : 2; //< Enum indicating the functioning mode of the AlphaFunction
};
/**
#include <dali/public-api/animation/animation.h>
// INTERNAL INCLUDES
-#include <dali/public-api/animation/alpha-function.h>
-#include <dali/public-api/animation/time-period.h>
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/animation/animation-impl.h>
#include <dali/internal/event/animation/path-impl.h>
+#include <dali/public-api/animation/alpha-function.h>
+#include <dali/public-api/animation/time-period.h>
namespace Dali
{
-
Animation::Animation()
{
}
return Animation(internal.Get());
}
-Animation Animation::DownCast( BaseHandle handle )
+Animation Animation::DownCast(BaseHandle handle)
{
- return Animation( dynamic_cast<Dali::Internal::Animation*>(handle.GetObjectPtr()) );
+ return Animation(dynamic_cast<Dali::Internal::Animation*>(handle.GetObjectPtr()));
}
Animation::~Animation()
Animation& Animation::operator=(const Animation& rhs) = default;
-Animation::Animation( Animation&& rhs ) = default;
+Animation::Animation(Animation&& rhs) = default;
-Animation& Animation::operator=( Animation&& rhs ) = default;
+Animation& Animation::operator=(Animation&& rhs) = default;
void Animation::SetDuration(float durationSeconds)
{
return GetImplementation(*this).GetEndAction();
}
-void Animation::SetDisconnectAction( Animation::EndAction disconnectAction )
+void Animation::SetDisconnectAction(Animation::EndAction disconnectAction)
{
- GetImplementation(*this).SetDisconnectAction( disconnectAction );
+ GetImplementation(*this).SetDisconnectAction(disconnectAction);
}
Animation::EndAction Animation::GetDisconnectAction() const
GetImplementation(*this).PlayFrom(progress);
}
-void Animation::PlayAfter( float delaySeconds )
+void Animation::PlayAfter(float delaySeconds)
{
- GetImplementation( *this ).PlayAfter( delaySeconds );
+ GetImplementation(*this).PlayAfter(delaySeconds);
}
void Animation::Pause()
GetImplementation(*this).Clear();
}
-void Animation::SetLoopingMode( LoopingMode loopingMode )
+void Animation::SetLoopingMode(LoopingMode loopingMode)
{
- GetImplementation( *this ).SetLoopingMode( loopingMode );
+ GetImplementation(*this).SetLoopingMode(loopingMode);
}
Animation::LoopingMode Animation::GetLoopingMode() const
{
- return GetImplementation( *this ).GetLoopingMode();
+ return GetImplementation(*this).GetLoopingMode();
}
Animation::AnimationSignalType& Animation::FinishedSignal()
GetImplementation(*this).AnimateTo(target, destinationValue, alpha, period);
}
-void Animation::AnimateBetween(Property target, KeyFrames& keyFrames )
+void Animation::AnimateBetween(Property target, KeyFrames& keyFrames)
{
- GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames) );
+ GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames));
}
void Animation::AnimateBetween(Property target, KeyFrames& keyFrames, Interpolation interpolation)
{
- GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), interpolation );
+ GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), interpolation);
}
void Animation::AnimateBetween(Property target, KeyFrames& keyFrames, TimePeriod period)
void Animation::AnimateBetween(Property target, KeyFrames& keyFrames, TimePeriod period, Interpolation interpolation)
{
- GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), period, interpolation );
+ GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), period, interpolation);
}
void Animation::AnimateBetween(Property target, KeyFrames& keyFrames, AlphaFunction alpha)
GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), alpha, interpolation);
}
-
void Animation::AnimateBetween(Property target, KeyFrames& keyFrames, AlphaFunction alpha, TimePeriod period)
{
GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), alpha, period);
GetImplementation(*this).AnimateBetween(target, GetImplementation(keyFrames), alpha, period, interpolation);
}
-
// Actor specific animations
-void Animation::Animate( Actor actor, Path path, const Vector3& forward )
+void Animation::Animate(Actor actor, Path path, const Vector3& forward)
{
- GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation( path ), forward );
+ GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation(path), forward);
}
-void Animation::Animate( Actor actor, Path path, const Vector3& forward, AlphaFunction alpha )
+void Animation::Animate(Actor actor, Path path, const Vector3& forward, AlphaFunction alpha)
{
- GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation( path ), forward, alpha );
+ GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation(path), forward, alpha);
}
-void Animation::Animate( Actor actor, Path path, const Vector3& forward, TimePeriod period )
+void Animation::Animate(Actor actor, Path path, const Vector3& forward, TimePeriod period)
{
- GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation( path ), forward, period);
+ GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation(path), forward, period);
}
-void Animation::Animate( Actor actor, Path path, const Vector3& forward, AlphaFunction alpha, TimePeriod period)
+void Animation::Animate(Actor actor, Path path, const Vector3& forward, AlphaFunction alpha, TimePeriod period)
{
- GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation( path ), forward, alpha, period );
+ GetImplementation(*this).Animate(GetImplementation(actor), GetImplementation(path), forward, alpha, period);
}
void Animation::Show(Actor actor, float delaySeconds)
GetImplementation(*this).Hide(GetImplementation(actor), delaySeconds);
}
-void Animation::SetCurrentProgress( float progress )
+void Animation::SetCurrentProgress(float progress)
{
- return GetImplementation(*this).SetCurrentProgress( progress );
+ return GetImplementation(*this).SetCurrentProgress(progress);
}
float Animation::GetCurrentProgress()
return GetImplementation(*this).GetCurrentProgress();
}
-void Animation::SetSpeedFactor( float factor )
+void Animation::SetSpeedFactor(float factor)
{
- GetImplementation(*this).SetSpeedFactor( factor );
+ GetImplementation(*this).SetSpeedFactor(factor);
}
float Animation::GetSpeedFactor() const
return GetImplementation(*this).GetSpeedFactor();
}
-void Animation::SetPlayRange( const Vector2& range )
+void Animation::SetPlayRange(const Vector2& range)
{
GetImplementation(*this).SetPlayRange(range);
}
class DALI_CORE_API Animation : public BaseHandle
{
public:
+ using AnimationSignalType = Signal<void(Animation&)>; ///< Animation finished signal type @SINCE_1_0.0
- typedef Signal< void (Animation&) > AnimationSignalType; ///< Animation finished signal type @SINCE_1_0.0
-
- typedef Any AnyFunction; ///< Interpolation function @SINCE_1_0.0
+ using AnyFunction = Any; ///< Interpolation function @SINCE_1_0.0
/**
* @brief Enumeration for what to do when the animation ends, is stopped, or is destroyed.
*/
enum EndAction
{
- BAKE, ///< When the animation ends, the animated property values are saved. @SINCE_1_0.0
- DISCARD, ///< When the animation ends, the animated property values are forgotten. @SINCE_1_0.0
+ BAKE, ///< When the animation ends, the animated property values are saved. @SINCE_1_0.0
+ DISCARD, ///< When the animation ends, the animated property values are forgotten. @SINCE_1_0.0
BAKE_FINAL ///< If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Bake. @SINCE_1_0.0
};
*/
enum Interpolation
{
- LINEAR, ///< Values in between key frames are interpolated using a linear polynomial. (Default) @SINCE_1_0.0
- CUBIC ///< Values in between key frames are interpolated using a cubic polynomial. @SINCE_1_0.0
+ LINEAR, ///< Values in between key frames are interpolated using a linear polynomial. (Default) @SINCE_1_0.0
+ CUBIC ///< Values in between key frames are interpolated using a cubic polynomial. @SINCE_1_0.0
};
/**
*/
enum State
{
- STOPPED, ///< Animation has stopped @SINCE_1_1.21
- PLAYING, ///< The animation is playing @SINCE_1_1.21
- PAUSED ///< The animation is paused @SINCE_1_1.21
+ STOPPED, ///< Animation has stopped @SINCE_1_1.21
+ PLAYING, ///< The animation is playing @SINCE_1_1.21
+ PAUSED ///< The animation is paused @SINCE_1_1.21
};
/**
*/
enum LoopingMode
{
- RESTART, ///< When the animation arrives at the end in looping mode, the animation restarts from the beginning. @SINCE_1_2.60
- AUTO_REVERSE ///< When the animation arrives at the end in looping mode, the animation reverses direction and runs backwards again. @SINCE_1_2.60
+ RESTART, ///< When the animation arrives at the end in looping mode, the animation restarts from the beginning. @SINCE_1_2.60
+ AUTO_REVERSE ///< When the animation arrives at the end in looping mode, the animation reverses direction and runs backwards again. @SINCE_1_2.60
};
/**
* @param[in] handle Handle to an object
* @return Handle to an Animation object or an uninitialized handle
*/
- static Animation DownCast( BaseHandle handle );
+ static Animation DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Animation( Animation&& rhs );
+ Animation(Animation&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Animation& operator=( Animation&& rhs );
+ Animation& operator=(Animation&& rhs);
/**
* @brief Sets the duration of an animation.
* @SINCE_1_1.20
* @param[in] count The number of times to loop
*/
- void SetLoopCount(int32_t count);
+ void SetLoopCount(int32_t count);
/**
* @brief Gets the loop count.
* @SINCE_1_1.20
* @return The number of times to loop
*/
- int32_t GetLoopCount();
+ int32_t GetLoopCount();
/**
* @brief Gets the current loop count.
* @SINCE_1_1.20
* @return The current number of loops that have occured
*/
- int32_t GetCurrentLoop();
+ int32_t GetCurrentLoop();
/**
* @brief Queries whether the animation will loop.
* @SINCE_1_0.0
* @param[in] disconnectAction The disconnect action
*/
- void SetDisconnectAction( EndAction disconnectAction );
+ void SetDisconnectAction(EndAction disconnectAction);
/**
* @brief Returns the disconnect action.
* @param[in] progress The new progress as a normalized value between [0,1]
* or between the play range if specified
*/
- void SetCurrentProgress( float progress );
+ void SetCurrentProgress(float progress);
/**
* @brief Retrieves the current progress of the animation.
* @SINCE_1_0.0
* @param[in] factor A value which will multiply the velocity
*/
- void SetSpeedFactor( float factor );
+ void SetSpeedFactor(float factor);
/**
* @brief Retrieves the speed factor of the animation.
* @param[in] range Two values between [0,1] to specify minimum and maximum progress. The
* animation will play between those values
*/
- void SetPlayRange( const Vector2& range );
+ void SetPlayRange(const Vector2& range);
/**
* @brief Gets the playing range.
* @SINCE_1_0.0
* @param[in] progress A value between [0,1], or between the play range if specified, from where the animation should start playing
*/
- void PlayFrom( float progress );
+ void PlayFrom(float progress);
/**
* @brief Play the animation after a given delay time.
* @SINCE_1_2.60
* @param[in] delaySeconds The delay time
*/
- void PlayAfter( float delaySeconds );
+ void PlayAfter(float delaySeconds);
/**
* @brief Pauses the animation.
* @SINCE_1_2.60
* @param[in] loopingMode The looping mode is one of RESTART and AUTO_REVERSE
*/
- void SetLoopingMode( LoopingMode loopingMode );
+ void SetLoopingMode(LoopingMode loopingMode);
/**
* @brief Gets one of the current looping mode.
*/
void AnimateTo(Property target, Property::Value destinationValue, AlphaFunction alpha, TimePeriod period);
- /**
+ /**
* @brief Animates a property between keyframes.
*
* @SINCE_1_0.0
*/
void AnimateBetween(Property target, KeyFrames& keyFrames, AlphaFunction alpha, TimePeriod period, Interpolation interpolation);
-
// Actor-specific convenience methods
/**
* @param[in] path The path. It defines position and orientation
* @param[in] forward The vector (in local space coordinate system) that will be oriented with the path's tangent direction
*/
- void Animate( Actor actor, Path path, const Vector3& forward );
+ void Animate(Actor actor, Path path, const Vector3& forward);
/**
* @brief Animates an actor's position and orientation through a predefined path.
* @param[in] forward The vector (in local space coordinate system) that will be oriented with the path's tangent direction
* @param[in] alpha The alpha function to apply
*/
- void Animate( Actor actor, Path path, const Vector3& forward, AlphaFunction alpha );
+ void Animate(Actor actor, Path path, const Vector3& forward, AlphaFunction alpha);
/**
* @brief Animates an actor's position and orientation through a predefined path.
* @param[in] forward The vector (in local space coordinate system) that will be oriented with the path's tangent direction
* @param[in] period The effect will occur during this time period
*/
- void Animate( Actor actor, Path path, const Vector3& forward, TimePeriod period );
+ void Animate(Actor actor, Path path, const Vector3& forward, TimePeriod period);
/**
* @brief Animates an actor's position and orientation through a predefined path.
* @param[in] alpha The alpha function to apply
* @param[in] period The effect will occur during this time period
*/
- void Animate( Actor actor, Path path, const Vector3& forward, AlphaFunction alpha, TimePeriod period);
+ void Animate(Actor actor, Path path, const Vector3& forward, AlphaFunction alpha, TimePeriod period);
/**
* @brief Shows an actor during the animation.
void Hide(Actor actor, float delaySeconds);
public: // Not intended for use by Application developers
-
/// @cond internal
/**
* @brief This constructor is used by Animation::New() methods.
*/
explicit DALI_INTERNAL Animation(Internal::Animation* animation);
/// @endcond
-
};
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-LocalSource::LocalSource( Property::Index index )
-: propertyIndex( index )
+LocalSource::LocalSource(Property::Index index)
+: propertyIndex(index)
{
}
-ParentSource::ParentSource( Property::Index index )
-: propertyIndex( index )
+ParentSource::ParentSource(Property::Index index)
+: propertyIndex(index)
{
}
-Source::Source( Handle& obj, Property::Index index )
-: propertyIndex( index ),
- object( obj )
+Source::Source(Handle& obj, Property::Index index)
+: propertyIndex(index),
+ object(obj)
{
}
-ConstraintSource::ConstraintSource( Source source )
-: sourceType( OBJECT_PROPERTY ),
- propertyIndex( source.propertyIndex ),
- object( source.object )
+ConstraintSource::ConstraintSource(Source source)
+: sourceType(OBJECT_PROPERTY),
+ propertyIndex(source.propertyIndex),
+ object(source.object)
{
}
-ConstraintSource::ConstraintSource( LocalSource local )
-: sourceType( LOCAL_PROPERTY ),
- propertyIndex( local.propertyIndex )
+ConstraintSource::ConstraintSource(LocalSource local)
+: sourceType(LOCAL_PROPERTY),
+ propertyIndex(local.propertyIndex)
{
}
-ConstraintSource::ConstraintSource( ParentSource parent )
-: sourceType( PARENT_PROPERTY ),
- propertyIndex( parent.propertyIndex )
+ConstraintSource::ConstraintSource(ParentSource parent)
+: sourceType(PARENT_PROPERTY),
+ propertyIndex(parent.propertyIndex)
{
}
#define DALI_CONSTRAINT_SOURCE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
PARENT_PROPERTY ///< The property comes from the parent of the object, which the constraint is applied to. @SINCE_1_0.0
};
-
/**
* @brief Identifies a property from an object.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] index The index of a property provided by the constrained object
*/
- LocalSource( Property::Index index );
+ LocalSource(Property::Index index);
Property::Index propertyIndex; ///< The index of a property provided by the constrained object.
};
* @SINCE_1_0.0
* @param[in] index The index of a property, provided by the parent of the constrained object
*/
- ParentSource( Property::Index index );
+ ParentSource(Property::Index index);
Property::Index propertyIndex; ///< The index of a property provided by the parent of the constrained object.
};
* @param[in] object The object providing the property
* @param[in] index The index of a property provided by object
*/
- Source( Handle& object, Property::Index index );
+ Source(Handle& object, Property::Index index);
Property::Index propertyIndex; ///< The index of a property provided by object.
* @SINCE_1_0.0
* @param[in] source A constraint source from an arbitrary object
*/
- ConstraintSource( Source source );
+ ConstraintSource(Source source);
/**
* @brief Creates a constraint source.
* @SINCE_1_0.0
* @param[in] local A local constraint source
*/
- ConstraintSource( LocalSource local );
+ ConstraintSource(LocalSource local);
/**
* @brief Creates a constraint source.
* @SINCE_1_0.0
* @param[in] parent A parent constraint source
*/
- ConstraintSource( ParentSource parent );
+ ConstraintSource(ParentSource parent);
SourceType sourceType; ///< The source type
namespace Dali
{
-
namespace // unnamed namespace
{
-
-template < class P >
-Internal::PropertyConstraint< P >* CreatePropertyConstraint( CallbackBase* func )
+template<class P>
+Internal::PropertyConstraint<P>* CreatePropertyConstraint(CallbackBase* func)
{
- return new Internal::PropertyConstraint< P >( reinterpret_cast< Dali::Constraint::Function< P >* >( func ) );
+ return new Internal::PropertyConstraint<P>(reinterpret_cast<Dali::Constraint::Function<P>*>(func));
}
} // unnamed namespace
{
}
-Constraint Constraint::Clone( Handle object )
+Constraint Constraint::Clone(Handle object)
{
- return Constraint( GetImplementation( *this ).Clone( GetImplementation( object ) ) );
+ return Constraint(GetImplementation(*this).Clone(GetImplementation(object)));
}
Constraint::~Constraint()
{
}
-Constraint::Constraint( const Constraint& constraint ) = default;
+Constraint::Constraint(const Constraint& constraint) = default;
-Constraint& Constraint::operator=( const Constraint& rhs ) = default;
+Constraint& Constraint::operator=(const Constraint& rhs) = default;
-Constraint::Constraint( Constraint&& rhs ) = default;
+Constraint::Constraint(Constraint&& rhs) = default;
-Constraint& Constraint::operator=( Constraint&& rhs ) = default;
+Constraint& Constraint::operator=(Constraint&& rhs) = default;
-Constraint Constraint::DownCast( BaseHandle baseHandle )
+Constraint Constraint::DownCast(BaseHandle baseHandle)
{
- return Constraint( dynamic_cast< Dali::Internal::ConstraintBase* >( baseHandle.GetObjectPtr() ) );
+ return Constraint(dynamic_cast<Dali::Internal::ConstraintBase*>(baseHandle.GetObjectPtr()));
}
-void Constraint::AddSource( ConstraintSource source )
+void Constraint::AddSource(ConstraintSource source)
{
- GetImplementation( *this ).AddSource( Internal::Source( source ) );
+ GetImplementation(*this).AddSource(Internal::Source(source));
}
void Constraint::Apply()
{
- GetImplementation( *this ).Apply();
+ GetImplementation(*this).Apply();
}
void Constraint::Remove()
{
- GetImplementation( *this ).Remove();
+ GetImplementation(*this).Remove();
}
Handle Constraint::GetTargetObject()
return GetImplementation(*this).GetRemoveAction();
}
-void Constraint::SetTag( const uint32_t tag )
+void Constraint::SetTag(const uint32_t tag)
{
- GetImplementation(*this).SetTag( tag );
+ GetImplementation(*this).SetTag(tag);
}
uint32_t Constraint::GetTag() const
return GetImplementation(*this).GetTag();
}
-Constraint::Constraint( Internal::ConstraintBase* constraint )
-: BaseHandle( constraint )
+Constraint::Constraint(Internal::ConstraintBase* constraint)
+: BaseHandle(constraint)
{
}
-Constraint Constraint::New( Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function )
+Constraint Constraint::New(Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function)
{
- Constraint constraint;
+ Constraint constraint;
Internal::SourceContainer sources;
- Internal::Object& object = GetImplementation( handle );
+ Internal::Object& object = GetImplementation(handle);
- switch ( targetType )
+ switch(targetType)
{
case Property::BOOLEAN:
{
- Internal::PropertyConstraintPtr< bool >::Type funcPtr( CreatePropertyConstraint< bool >( function ) );
+ Internal::PropertyConstraintPtr<bool>::Type funcPtr(CreatePropertyConstraint<bool>(function));
- constraint = Dali::Constraint( Internal::Constraint< bool >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<bool>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::FLOAT:
{
- Internal::PropertyConstraintPtr< float >::Type funcPtr( CreatePropertyConstraint< float >( function ) );
+ Internal::PropertyConstraintPtr<float>::Type funcPtr(CreatePropertyConstraint<float>(function));
- constraint = Dali::Constraint( Internal::Constraint< float >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<float>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::INTEGER:
{
- Internal::PropertyConstraintPtr< int >::Type funcPtr( CreatePropertyConstraint< int >( function ) );
+ Internal::PropertyConstraintPtr<int>::Type funcPtr(CreatePropertyConstraint<int>(function));
- constraint = Dali::Constraint( Internal::Constraint< int >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<int>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::VECTOR2:
{
- Internal::PropertyConstraintPtr< Vector2 >::Type funcPtr( CreatePropertyConstraint< Vector2 >( function ) );
+ Internal::PropertyConstraintPtr<Vector2>::Type funcPtr(CreatePropertyConstraint<Vector2>(function));
- constraint = Dali::Constraint( Internal::Constraint< Vector2 >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<Vector2>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::VECTOR3:
{
- Internal::PropertyConstraintPtr< Vector3 >::Type funcPtr( CreatePropertyConstraint< Vector3 >( function ) );
+ Internal::PropertyConstraintPtr<Vector3>::Type funcPtr(CreatePropertyConstraint<Vector3>(function));
- constraint = Dali::Constraint( Internal::Constraint< Vector3 >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<Vector3>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::VECTOR4:
{
- Internal::PropertyConstraintPtr< Vector4 >::Type funcPtr( CreatePropertyConstraint< Vector4 >( function ) );
+ Internal::PropertyConstraintPtr<Vector4>::Type funcPtr(CreatePropertyConstraint<Vector4>(function));
- constraint = Dali::Constraint( Internal::Constraint< Vector4 >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<Vector4>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::ROTATION:
{
- Internal::PropertyConstraintPtr< Quaternion >::Type funcPtr( CreatePropertyConstraint< Quaternion >( function ) );
+ Internal::PropertyConstraintPtr<Quaternion>::Type funcPtr(CreatePropertyConstraint<Quaternion>(function));
- constraint = Dali::Constraint( Internal::Constraint< Quaternion >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<Quaternion>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::MATRIX:
{
- Internal::PropertyConstraintPtr< Matrix >::Type funcPtr( CreatePropertyConstraint< Matrix >( function ) );
+ Internal::PropertyConstraintPtr<Matrix>::Type funcPtr(CreatePropertyConstraint<Matrix>(function));
- constraint = Dali::Constraint( Internal::Constraint< Matrix >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<Matrix>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
case Property::MATRIX3:
{
- Internal::PropertyConstraintPtr<Matrix3>::Type funcPtr( CreatePropertyConstraint<Matrix3>( function ) );
+ Internal::PropertyConstraintPtr<Matrix3>::Type funcPtr(CreatePropertyConstraint<Matrix3>(function));
- constraint = Dali::Constraint( Internal::Constraint< Matrix3 >::New( object,
- targetIndex,
- sources,
- funcPtr ) );
+ constraint = Dali::Constraint(Internal::Constraint<Matrix3>::New(object,
+ targetIndex,
+ sources,
+ funcPtr));
break;
}
default:
{
- DALI_ABORT( "Property not constrainable" );
+ DALI_ABORT("Property not constrainable");
break;
}
}
#include <dali/public-api/animation/constraint-source.h>
#include <dali/public-api/common/dali-vector.h>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/object/property.h>
#include <dali/public-api/object/property-input.h>
+#include <dali/public-api/object/property.h>
#include <dali/public-api/signals/callback.h>
namespace Dali
class ConstraintBase;
}
-typedef Vector< PropertyInput* > PropertyInputContainer;
+using PropertyInputContainer = Vector<PropertyInput*>;
/**
* @brief An abstract base class for Constraints.
class DALI_CORE_API Constraint : public BaseHandle
{
public:
-
/**
* @brief Template for the Function that is called by the Constraint system.
*
* @SINCE_1_0.0
* @tparam P The property type to constrain
*/
- template< typename P >
+ template<typename P>
class DALI_INTERNAL Function : public CallbackBase
{
public:
-
/**
* @brief Constructor which connects to the provided C function (or a static member function).
*
* @SINCE_1_0.0
* @param[in] function The function to call
*/
- Function( void( *function )( P&, const PropertyInputContainer& ) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) ),
- mCopyConstructorDispatcher( NULL )
+ Function(void (*function)(P&, const PropertyInputContainer&))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function)),
+ mCopyConstructorDispatcher(NULL)
{
}
* @param[in] object The object to copy
* @tparam T The type of the object
*/
- template< class T >
- Function( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcher2< T, P&, const PropertyInputContainer& >::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer< T >::Delete ) ),
- mCopyConstructorDispatcher( reinterpret_cast< CopyConstructorDispatcher >( &ObjectCopyConstructorDispatcher< T >::Copy ) )
+ template<class T>
+ Function(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ nullptr, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcher2<T, P&, const PropertyInputContainer&>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete)),
+ mCopyConstructorDispatcher(reinterpret_cast<CopyConstructorDispatcher>(&ObjectCopyConstructorDispatcher<T>::Copy))
{
}
* @param[in] memberFunction The member function to call. This has to be a member of the same class
* @tparam T The type of the object
*/
- template< class T >
- Function( const T& object, void ( T::*memberFunction ) ( P&, const PropertyInputContainer& ) )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &Dispatcher2< T, P&, const PropertyInputContainer& >::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer< T >::Delete ) ),
- mCopyConstructorDispatcher( reinterpret_cast< CopyConstructorDispatcher >( &ObjectCopyConstructorDispatcher< T >::Copy ) )
+ template<class T>
+ Function(const T& object, void (T::*memberFunction)(P&, const PropertyInputContainer&))
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&Dispatcher2<T, P&, const PropertyInputContainer&>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete)),
+ mCopyConstructorDispatcher(reinterpret_cast<CopyConstructorDispatcher>(&ObjectCopyConstructorDispatcher<T>::Copy))
{
}
*/
CallbackBase* Clone()
{
- CallbackBase* callback = NULL;
- if ( mImpl && mImpl->mObjectPointer && mCopyConstructorDispatcher )
+ CallbackBase* callback = nullptr;
+ if(mImpl && mImpl->mObjectPointer && mCopyConstructorDispatcher)
{
- callback = new Function( mCopyConstructorDispatcher( reinterpret_cast< UndefinedClass* >( mImpl->mObjectPointer ) ) /* Copy the object */,
- mMemberFunction,
- mImpl->mMemberFunctionDispatcher,
- mImpl->mDestructorDispatcher,
- mCopyConstructorDispatcher );
+ callback = new Function(mCopyConstructorDispatcher(reinterpret_cast<UndefinedClass*>(mImpl->mObjectPointer)) /* Copy the object */,
+ mMemberFunction,
+ mImpl->mMemberFunctionDispatcher,
+ mImpl->mDestructorDispatcher,
+ mCopyConstructorDispatcher);
}
else
{
- callback = new Function( mFunction );
+ callback = new Function(mFunction);
}
return callback;
}
private:
-
/**
* @brief Must not be declared.
*
* @brief Used to call the function to copy the stored object.
* @SINCE_1_0.0
*/
- typedef UndefinedClass* (*CopyConstructorDispatcher) ( UndefinedClass* object );
+ using CopyConstructorDispatcher = UndefinedClass* (*)(UndefinedClass*);
/**
* @brief Copies the actual object in Constraint::Function.
* @SINCE_1_0.0
* @tparam T The type of the object
*/
- template< class T >
+ template<class T>
struct ObjectCopyConstructorDispatcher
{
/**
* @param[in] object The object to copy
* @return Newly allocated clone of the object
*/
- static UndefinedClass* Copy( const UndefinedClass* object )
+ static UndefinedClass* Copy(const UndefinedClass* object)
{
- T* copy = new T( *( reinterpret_cast< const T* >( object ) ) );
- return reinterpret_cast< UndefinedClass* >( copy );
+ T* copy = new T(*(reinterpret_cast<const T*>(object)));
+ return reinterpret_cast<UndefinedClass*>(copy);
}
};
- Function( const Function& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- Function( Function&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- Function& operator=( const Function& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- Function& operator=( Function&& ) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
+ Function(const Function&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ Function(Function&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ Function& operator=(const Function&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ Function& operator=(Function&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
/**
* @brief Constructor used when copying the stored object.
* @param[in] destructor Used to delete the owned object
* @param[in] copyConstructorDispatcher Used to create a copy of the owned object
*/
- Function( void* object,
- CallbackBase::MemberFunction memberFunction,
- CallbackBase::Dispatcher dispatcher,
- CallbackBase::Destructor destructor,
- CopyConstructorDispatcher copyConstructorDispatcher )
- : CallbackBase( object, memberFunction, dispatcher, destructor ),
- mCopyConstructorDispatcher( copyConstructorDispatcher )
+ Function(void* object,
+ CallbackBase::MemberFunction memberFunction,
+ CallbackBase::Dispatcher dispatcher,
+ CallbackBase::Destructor destructor,
+ CopyConstructorDispatcher copyConstructorDispatcher)
+ : CallbackBase(object, memberFunction, dispatcher, destructor),
+ mCopyConstructorDispatcher(copyConstructorDispatcher)
{
}
* @SINCE_1_0.0
* @param[in] function The function to call
*/
- Function( CallbackBase::Function function )
- : CallbackBase( function ),
- mCopyConstructorDispatcher( NULL )
+ Function(CallbackBase::Function function)
+ : CallbackBase(function),
+ mCopyConstructorDispatcher(nullptr)
{
}
DISCARD ///< When the constraint is removed, the constrained value is discarded. @SINCE_1_9.28
};
- static const RemoveAction DEFAULT_REMOVE_ACTION; ///< BAKE
+ static const RemoveAction DEFAULT_REMOVE_ACTION; ///< BAKE
/**
* @brief Creates an uninitialized Constraint; this can be initialized with Constraint::New().
* @tparam P The type of the property to constrain
* @return The new constraint
*/
- template< class P >
- static Constraint New( Handle handle, Property::Index targetIndex, void( *function )( P&, const PropertyInputContainer& ) )
+ template<class P>
+ static Constraint New(Handle handle, Property::Index targetIndex, void (*function)(P&, const PropertyInputContainer&))
{
- CallbackBase* callback = new Constraint::Function< P >( function );
- return New( handle, targetIndex, PropertyTypes::Get< P >(), callback );
+ CallbackBase* callback = new Constraint::Function<P>(function);
+ return New(handle, targetIndex, PropertyTypes::Get<P>(), callback);
}
/**
* @tparam T The type of the object
* @return The new constraint
*/
- template< class P, class T >
- static Constraint New( Handle handle, Property::Index targetIndex, const T& object )
+ template<class P, class T>
+ static Constraint New(Handle handle, Property::Index targetIndex, const T& object)
{
- CallbackBase* function = new Constraint::Function< P >( object );
- return New( handle, targetIndex, PropertyTypes::Get< P >(), function );
+ CallbackBase* function = new Constraint::Function<P>(object);
+ return New(handle, targetIndex, PropertyTypes::Get<P>(), function);
}
/**
* @tparam P The type of the property to constrain
* @tparam T The type of the object
*/
- template< class P, class T >
- static Constraint New( Handle handle, Property::Index targetIndex, const T& object, void ( T::*memberFunction ) ( P&, const PropertyInputContainer& ) )
+ template<class P, class T>
+ static Constraint New(Handle handle, Property::Index targetIndex, const T& object, void (T::*memberFunction)(P&, const PropertyInputContainer&))
{
- CallbackBase* function = new Constraint::Function< P >( object, memberFunction );
- return New( handle, targetIndex, PropertyTypes::Get< P >(), function );
+ CallbackBase* function = new Constraint::Function<P>(object, memberFunction);
+ return New(handle, targetIndex, PropertyTypes::Get<P>(), function);
}
/**
* @param[in] handle The handle to the property-owning object this constraint is to be cloned for
* @return The new constraint
*/
- Constraint Clone( Handle handle );
+ Constraint Clone(Handle handle);
/**
* @brief Destructor.
* @SINCE_1_0.0
* @param[in] constraint A reference to the copied handle
*/
- Constraint( const Constraint& constraint );
+ Constraint(const Constraint& constraint);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- Constraint& operator=( const Constraint& rhs );
+ Constraint& operator=(const Constraint& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Constraint( Constraint&& rhs );
+ Constraint(Constraint&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Constraint& operator=( Constraint&& rhs );
+ Constraint& operator=(Constraint&& rhs);
/**
* @brief Downcasts a handle to Constraint handle.
* @param[in] baseHandle BaseHandle to an object
* @return Handle to a Constraint object or an uninitialized handle
*/
- static Constraint DownCast( BaseHandle baseHandle );
+ static Constraint DownCast(BaseHandle baseHandle);
/**
* @brief Adds a constraint source to the constraint.
* @SINCE_1_0.0
* @param[in] source The constraint source input to add
*/
- void AddSource( ConstraintSource source );
+ void AddSource(ConstraintSource source);
/**
* @brief Applies this constraint.
* @SINCE_1_0.0
* @param[in] action The remove-action
*/
- void SetRemoveAction( RemoveAction action );
+ void SetRemoveAction(RemoveAction action);
/**
* @brief Retrieves the remove action that will happen when the constraint is removed.
* @SINCE_1_0.0
* @param[in] tag An integer to identify the constraint
*/
- void SetTag( const uint32_t tag );
+ void SetTag(const uint32_t tag);
/**
* @brief Gets the tag.
uint32_t GetTag() const;
public: // Not intended for use by Application developers
-
/// @cond internal
/**
* @brief This constructor is used by Constraint::New() methods.
* @SINCE_1_0.0
* @param[in] constraint A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL Constraint( Internal::ConstraintBase* constraint );
+ explicit DALI_INTERNAL Constraint(Internal::ConstraintBase* constraint);
/// @endcond
private: // Not intended for use by Application developers
-
/// @cond internal
/**
* @brief Constructs a new constraint which targets a property.
* @param[in] function The constraint function
* @return The new constraint
*/
- static Constraint New( Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function );
+ static Constraint New(Handle handle, Property::Index targetIndex, Property::Type targetType, CallbackBase* function);
/// @endcond
};
#define DALI_CONSTRAINTS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// INTERNAL INCLUDES
#include <dali/public-api/animation/constraint.h>
-#include <dali/public-api/math/vector3.h>
-#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/quaternion.h>
#include <dali/public-api/math/matrix.h>
#include <dali/public-api/math/matrix3.h>
+#include <dali/public-api/math/quaternion.h>
+#include <dali/public-api/math/vector3.h>
+#include <dali/public-api/math/vector4.h>
#include <dali/public-api/object/property-input.h>
namespace Dali
* @SINCE_1_0.0
*/
EqualToConstraint()
- { }
+ {
+ }
/**
* @brief Overrides functor for float properties.
* @param[in,out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
- void operator()( float& current, const PropertyInputContainer& inputs )
+ void operator()(float& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetFloat();
}
* @param[in,out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
- void operator()( Vector2& current, const PropertyInputContainer& inputs )
+ void operator()(Vector2& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetVector2();
}
* @param[in,out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
- void operator()( Vector3& current, const PropertyInputContainer& inputs )
+ void operator()(Vector3& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetVector3();
}
* @param[in,out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
- void operator()( Vector4& current, const PropertyInputContainer& inputs )
+ void operator()(Vector4& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetVector4();
}
* @param[in,out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
- void operator()( Quaternion& current, const PropertyInputContainer& inputs )
+ void operator()(Quaternion& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetQuaternion();
}
* @param[in,out] current The current property value
* @param[in] inputs Contains the property to copy
*/
- void operator()( Matrix3& current, const PropertyInputContainer& inputs )
+ void operator()(Matrix3& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetMatrix3();
}
* @param[in,out] current The current property value, the constrained value is set
* @param[in] inputs Contains the property to copy
*/
- void operator()( Matrix& current, const PropertyInputContainer& inputs )
+ void operator()(Matrix& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetMatrix();
}
-
};
/**
* @SINCE_1_0.0
* @param[in] scale Scale factor
*/
- RelativeToConstraint( float scale )
- : mScale( scale, scale, scale ) { }
+ RelativeToConstraint(float scale)
+ : mScale(scale, scale, scale)
+ {
+ }
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param[in] scale Scale factor
*/
- RelativeToConstraint( const Vector3& scale )
- : mScale( scale ) { }
+ RelativeToConstraint(const Vector3& scale)
+ : mScale(scale)
+ {
+ }
/**
* @brief Functor.
* @param[in,out] current The current property value (vector3 property * scale factor)
* @param[in] inputs Property container for current property calculation
*/
- void operator()( Vector3& current, const PropertyInputContainer& inputs )
+ void operator()(Vector3& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetVector3() * mScale;
}
* @SINCE_1_0.0
* @param[in] scale Scale factor
*/
- RelativeToConstraintFloat( float scale )
- : mScale( scale ) { }
+ RelativeToConstraintFloat(float scale)
+ : mScale(scale)
+ {
+ }
/**
* @brief Functor.
* @param[in,out] current The current property value (float property * scale factor)
* @param[in] inputs Property container for current property calculation
*/
- void operator()( float& current, const PropertyInputContainer& inputs )
+ void operator()(float& current, const PropertyInputContainer& inputs)
{
current = inputs[0]->GetFloat() * mScale;
}
* @param[in,out] current The current orientation property value, the constrained value is set
* @param[in] inputs Contains the world position of the target, the world position of the camera, and the world orientation of the target
*/
-inline void LookAt( Dali::Quaternion& current, const Dali::PropertyInputContainer& inputs )
+inline void LookAt(Dali::Quaternion& current, const Dali::PropertyInputContainer& inputs)
{
- const PropertyInput& targetPosition( *inputs[0] );
- const PropertyInput& cameraPosition( *inputs[1] );
- const PropertyInput& targetOrientation( *inputs[2] );
+ const PropertyInput& targetPosition(*inputs[0]);
+ const PropertyInput& cameraPosition(*inputs[1]);
+ const PropertyInput& targetOrientation(*inputs[2]);
Vector3 vForward = targetPosition.GetVector3() - cameraPosition.GetVector3();
vForward.Normalize();
Vector3 vY = vForward.Cross(vX);
vY.Normalize();
- current = Quaternion( vX, vY, vForward );
+ current = Quaternion(vX, vY, vForward);
}
/**
#include <dali/public-api/animation/key-frames.h>
// INTERNAL INCLUDES
+#include <dali/internal/event/animation/key-frames-impl.h>
#include <dali/public-api/animation/alpha-function.h>
#include <dali/public-api/math/degree.h>
#include <dali/public-api/math/radian.h>
-#include <dali/internal/event/animation/key-frames-impl.h>
namespace Dali
{
-
KeyFrames KeyFrames::New()
{
Internal::KeyFrames* internal = Internal::KeyFrames::New();
return KeyFrames(internal);
}
-KeyFrames KeyFrames::DownCast( BaseHandle handle )
+KeyFrames KeyFrames::DownCast(BaseHandle handle)
{
- return KeyFrames( dynamic_cast<Dali::Internal::KeyFrames*>(handle.GetObjectPtr()) );
+ return KeyFrames(dynamic_cast<Dali::Internal::KeyFrames*>(handle.GetObjectPtr()));
}
KeyFrames::KeyFrames()
KeyFrames& KeyFrames::operator=(const KeyFrames& rhs) = default;
-KeyFrames::KeyFrames( KeyFrames&& rhs ) = default;
+KeyFrames::KeyFrames(KeyFrames&& rhs) = default;
-KeyFrames& KeyFrames::operator=( KeyFrames&& rhs ) = default;
+KeyFrames& KeyFrames::operator=(KeyFrames&& rhs) = default;
Property::Type KeyFrames::GetType() const
{
}
KeyFrames::KeyFrames(Internal::KeyFrames* internal)
- : BaseHandle(internal)
+: BaseHandle(internal)
{
}
-
-
-} // Dali
+} // namespace Dali
// INTERNAL INCLUDES
#include <dali/public-api/animation/alpha-function.h>
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/object/property-value.h>
#include <dali/public-api/object/property-types.h>
+#include <dali/public-api/object/property-value.h>
namespace Dali
{
* @param[in] handle Handle to an object
* @return Handle to a KeyFrames object or an uninitialized handle
*/
- static KeyFrames DownCast( BaseHandle handle );
+ static KeyFrames DownCast(BaseHandle handle);
/**
* @brief Creates an uninitialized KeyFrame handle.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- KeyFrames( KeyFrames&& rhs );
+ KeyFrames(KeyFrames&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- KeyFrames& operator=( KeyFrames&& rhs );
+ KeyFrames& operator=(KeyFrames&& rhs);
/**
* @brief Gets the type of the key frame.
*/
void Add(float progress, Property::Value value, AlphaFunction alpha);
-
public: // Not intended for application developers
/// @cond internal
/**
// INTERNAL INCLUDES
#include <dali/internal/event/animation/linear-constrainer-impl.h>
-
namespace Dali
{
-
LinearConstrainer LinearConstrainer::New()
{
Internal::LinearConstrainer* internal = Internal::LinearConstrainer::New();
return LinearConstrainer(internal);
}
-LinearConstrainer LinearConstrainer::DownCast( BaseHandle handle )
+LinearConstrainer LinearConstrainer::DownCast(BaseHandle handle)
{
- return LinearConstrainer( dynamic_cast<Dali::Internal::LinearConstrainer*>(handle.GetObjectPtr()) );
+ return LinearConstrainer(dynamic_cast<Dali::Internal::LinearConstrainer*>(handle.GetObjectPtr()));
}
LinearConstrainer::LinearConstrainer()
LinearConstrainer& LinearConstrainer::operator=(const LinearConstrainer& rhs) = default;
-LinearConstrainer::LinearConstrainer( LinearConstrainer&& rhs ) = default;
+LinearConstrainer::LinearConstrainer(LinearConstrainer&& rhs) = default;
-LinearConstrainer& LinearConstrainer::operator=( LinearConstrainer&& rhs ) = default;
+LinearConstrainer& LinearConstrainer::operator=(LinearConstrainer&& rhs) = default;
-void LinearConstrainer::Apply( Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap )
+void LinearConstrainer::Apply(Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap)
{
- GetImplementation(*this).Apply( target, source, range, wrap );
+ GetImplementation(*this).Apply(target, source, range, wrap);
}
-void LinearConstrainer::Remove( Dali::Handle& target )
+void LinearConstrainer::Remove(Dali::Handle& target)
{
- GetImplementation(*this).Remove( target );
+ GetImplementation(*this).Remove(target);
}
-
-} // Dali
+} // namespace Dali
namespace Internal DALI_INTERNAL
{
- class LinearConstrainer;
+class LinearConstrainer;
}
/**
class DALI_CORE_API LinearConstrainer : public Handle
{
public:
-
/**
* @brief Enumeration for the instance of properties belonging to the LinearConstrainer class.
* @SINCE_1_0.0
*/
enum
{
- VALUE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "value" type Array of float @SINCE_1_0.0
- PROGRESS, ///< name "progress" type Array of float @SINCE_1_0.0
+ VALUE = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "value" type Array of float @SINCE_1_0.0
+ PROGRESS, ///< name "progress" type Array of float @SINCE_1_0.0
};
};
* @param[in] handle Handle to an object
* @return Handle to a LinearConstrainer object or an uninitialized handle
*/
- static LinearConstrainer DownCast( BaseHandle handle );
+ static LinearConstrainer DownCast(BaseHandle handle);
/**
* @brief Creates an uninitialized LinearConstrainer handle.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- LinearConstrainer( LinearConstrainer&& rhs );
+ LinearConstrainer(LinearConstrainer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- LinearConstrainer& operator=( LinearConstrainer&& rhs );
+ LinearConstrainer& operator=(LinearConstrainer&& rhs);
/**
* @brief Applies the linear constraint to the target property.
* @param[in] range The range of values in the source property which will be mapped to [0,1]
* @param[in] wrap Wrapping domain. Source property will be wrapped in the domain [wrap.x,wrap.y] before mapping to [0,1]. See cfloat.h for FLT_MAX
*/
- void Apply( Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap = Vector2(-FLT_MAX, FLT_MAX) );
+ void Apply(Dali::Property target, Dali::Property source, const Vector2& range, const Vector2& wrap = Vector2(-FLT_MAX, FLT_MAX));
/**
* @brief Removes the linear constraint in the target object.
* @SINCE_1_0.0
* @param[in] target A handle to an object constrained by the LinearConstrainer
*/
- void Remove( Dali::Handle& target );
+ void Remove(Dali::Handle& target);
public: // Not intended for application developers
/// @cond internal
*/
// CLASS HEADER
-#include <dali/public-api/animation/path.h>
#include <dali/internal/event/animation/path-impl.h>
+#include <dali/public-api/animation/path.h>
// INTERNAL INCLUDES
namespace Dali
{
-
Path Path::New()
{
Internal::Path* internal = Internal::Path::New();
return Path(internal);
}
-Path Path::DownCast( BaseHandle handle )
+Path Path::DownCast(BaseHandle handle)
{
- return Path( dynamic_cast<Dali::Internal::Path*>(handle.GetObjectPtr()) );
+ return Path(dynamic_cast<Dali::Internal::Path*>(handle.GetObjectPtr()));
}
Path::Path()
Path& Path::operator=(const Path& rhs) = default;
-Path::Path( Path&& rhs ) = default;
+Path::Path(Path&& rhs) = default;
-Path& Path::operator=( Path&& rhs ) = default;
+Path& Path::operator=(Path&& rhs) = default;
-void Path::AddPoint(const Vector3& point )
+void Path::AddPoint(const Vector3& point)
{
- GetImplementation(*this).AddPoint( point );
+ GetImplementation(*this).AddPoint(point);
}
-void Path::AddControlPoint(const Vector3& point )
+void Path::AddControlPoint(const Vector3& point)
{
- GetImplementation(*this).AddControlPoint( point );
+ GetImplementation(*this).AddControlPoint(point);
}
-void Path::GenerateControlPoints( float curvature )
+void Path::GenerateControlPoints(float curvature)
{
- GetImplementation(*this).GenerateControlPoints( curvature );
+ GetImplementation(*this).GenerateControlPoints(curvature);
}
-
-void Path::Sample( float progress, Vector3& position, Vector3& tangent ) const
+void Path::Sample(float progress, Vector3& position, Vector3& tangent) const
{
- GetImplementation(*this).Sample( progress, position, tangent );
+ GetImplementation(*this).Sample(progress, position, tangent);
}
-Vector3& Path::GetPoint( size_t index )
+Vector3& Path::GetPoint(size_t index)
{
- return GetImplementation(*this).GetPoint( static_cast<uint32_t>( index ) );
+ return GetImplementation(*this).GetPoint(static_cast<uint32_t>(index));
}
-Vector3& Path::GetControlPoint( size_t index )
+Vector3& Path::GetControlPoint(size_t index)
{
- return GetImplementation(*this).GetControlPoint( static_cast<uint32_t>( index ) );
+ return GetImplementation(*this).GetControlPoint(static_cast<uint32_t>(index));
}
size_t Path::GetPointCount() const
return GetImplementation(*this).GetPointCount();
}
-} // Dali
+} // namespace Dali
class DALI_CORE_API Path : public Handle
{
public:
-
/**
* @brief Enumeration for the instance of properties belonging to the Path class.
* @SINCE_1_0.0
*/
enum
{
- POINTS = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "points", type Vector3 @SINCE_1_0.0
- CONTROL_POINTS, ///< name "controlPoints", type Vector3 @SINCE_1_0.0
+ POINTS = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< name "points", type Vector3 @SINCE_1_0.0
+ CONTROL_POINTS, ///< name "controlPoints", type Vector3 @SINCE_1_0.0
};
};
* @param[in] handle Handle to an object
* @return Handle to a Path object or an uninitialized handle
*/
- static Path DownCast( BaseHandle handle );
+ static Path DownCast(BaseHandle handle);
/**
* @brief Creates an uninitialized Path handle.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Path( Path&& rhs );
+ Path(Path&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Path& operator=( Path&& rhs );
+ Path& operator=(Path&& rhs);
/**
* @brief Adds an interpolation point.
* @SINCE_1_0.0
* @param[in] point The new interpolation point to be added
*/
- void AddPoint(const Vector3& point );
+ void AddPoint(const Vector3& point);
/**
* @brief Adds a control point.
* @SINCE_1_0.0
* @param[in] point The new control point to be added
*/
- void AddControlPoint(const Vector3& point );
+ void AddControlPoint(const Vector3& point);
/**
* @brief Automatic generation of control points. Generated control points which result in a smooth join between the splines of each segment.
* @pre There are at least two points in the path ( one segment ).
*
*/
- void GenerateControlPoints( float curvature );
+ void GenerateControlPoints(float curvature);
/**
* @brief Sample path at a given progress. Calculates position and tangent at that point of the curve.
* @param[out] position The interpolated position at that progress
* @param[out] tangent The interpolated tangent at that progress
*/
- void Sample( float progress, Vector3& position, Vector3& tangent ) const;
+ void Sample(float progress, Vector3& position, Vector3& tangent) const;
/**
* @brief Accessor for the interpolation points.
* @param[in] index The index of the interpolation point
* @return A reference to the interpolation point
*/
- Vector3& GetPoint( size_t index );
+ Vector3& GetPoint(size_t index);
/**
* @brief Accessor for the control points.
* @param[in] index The index of the control point
* @return A reference to the control point
*/
- Vector3& GetControlPoint( size_t index );
+ Vector3& GetControlPoint(size_t index);
/**
* @brief Gets the number of interpolation points in the path.
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
TimePeriod::TimePeriod(float duration)
: delaySeconds(0.0f),
durationSeconds(duration)
*/
namespace ParentOrigin
{
-static constexpr float TOP = 0.0f;
-static constexpr float BOTTOM = 1.0f;
-static constexpr float LEFT = 0.0f;
-static constexpr float RIGHT = 1.0f;
-static constexpr float MIDDLE = 0.5f;
-static constexpr Vector3 TOP_LEFT (0.0f, 0.0f, 0.5f);
-static constexpr Vector3 TOP_CENTER (0.5f, 0.0f, 0.5f);
-static constexpr Vector3 TOP_RIGHT (1.0f, 0.0f, 0.5f);
-static constexpr Vector3 CENTER_LEFT (0.0f, 0.5f, 0.5f);
-static constexpr Vector3 CENTER (0.5f, 0.5f, 0.5f);
-static constexpr Vector3 CENTER_RIGHT (1.0f, 0.5f, 0.5f);
-static constexpr Vector3 BOTTOM_LEFT (0.0f, 1.0f, 0.5f);
+static constexpr float TOP = 0.0f;
+static constexpr float BOTTOM = 1.0f;
+static constexpr float LEFT = 0.0f;
+static constexpr float RIGHT = 1.0f;
+static constexpr float MIDDLE = 0.5f;
+static constexpr Vector3 TOP_LEFT(0.0f, 0.0f, 0.5f);
+static constexpr Vector3 TOP_CENTER(0.5f, 0.0f, 0.5f);
+static constexpr Vector3 TOP_RIGHT(1.0f, 0.0f, 0.5f);
+static constexpr Vector3 CENTER_LEFT(0.0f, 0.5f, 0.5f);
+static constexpr Vector3 CENTER(0.5f, 0.5f, 0.5f);
+static constexpr Vector3 CENTER_RIGHT(1.0f, 0.5f, 0.5f);
+static constexpr Vector3 BOTTOM_LEFT(0.0f, 1.0f, 0.5f);
static constexpr Vector3 BOTTOM_CENTER(0.5f, 1.0f, 0.5f);
-static constexpr Vector3 BOTTOM_RIGHT (1.0f, 1.0f, 0.5f);
-static constexpr Vector3 DEFAULT( TOP_LEFT );
-}
+static constexpr Vector3 BOTTOM_RIGHT(1.0f, 1.0f, 0.5f);
+static constexpr Vector3 DEFAULT(TOP_LEFT);
+} // namespace ParentOrigin
/**
* @brief AnchorPoint constants.
*/
namespace AnchorPoint
{
-static constexpr float TOP = 0.0f;
-static constexpr float BOTTOM = 1.0f;
-static constexpr float LEFT = 0.0f;
-static constexpr float RIGHT = 1.0f;
-static constexpr float MIDDLE = 0.5f;
-static constexpr Vector3 TOP_LEFT (0.0f, 0.0f, 0.5f);
-static constexpr Vector3 TOP_CENTER (0.5f, 0.0f, 0.5f);
-static constexpr Vector3 TOP_RIGHT (1.0f, 0.0f, 0.5f);
-static constexpr Vector3 CENTER_LEFT (0.0f, 0.5f, 0.5f);
-static constexpr Vector3 CENTER (0.5f, 0.5f, 0.5f);
-static constexpr Vector3 CENTER_RIGHT (1.0f, 0.5f, 0.5f);
-static constexpr Vector3 BOTTOM_LEFT (0.0f, 1.0f, 0.5f);
+static constexpr float TOP = 0.0f;
+static constexpr float BOTTOM = 1.0f;
+static constexpr float LEFT = 0.0f;
+static constexpr float RIGHT = 1.0f;
+static constexpr float MIDDLE = 0.5f;
+static constexpr Vector3 TOP_LEFT(0.0f, 0.0f, 0.5f);
+static constexpr Vector3 TOP_CENTER(0.5f, 0.0f, 0.5f);
+static constexpr Vector3 TOP_RIGHT(1.0f, 0.0f, 0.5f);
+static constexpr Vector3 CENTER_LEFT(0.0f, 0.5f, 0.5f);
+static constexpr Vector3 CENTER(0.5f, 0.5f, 0.5f);
+static constexpr Vector3 CENTER_RIGHT(1.0f, 0.5f, 0.5f);
+static constexpr Vector3 BOTTOM_LEFT(0.0f, 1.0f, 0.5f);
static constexpr Vector3 BOTTOM_CENTER(0.5f, 1.0f, 0.5f);
-static constexpr Vector3 BOTTOM_RIGHT (1.0f, 1.0f, 0.5f);
-static constexpr Vector3 DEFAULT( CENTER );
-}
-
+static constexpr Vector3 BOTTOM_RIGHT(1.0f, 1.0f, 0.5f);
+static constexpr Vector3 DEFAULT(CENTER);
+} // namespace AnchorPoint
/**
* @brief Color Constants.
*/
namespace Color
{
-static constexpr Vector4 BLACK( 0.0f, 0.0f, 0.0f, 1.0f );
-static constexpr Vector4 WHITE( 1.0f, 1.0f, 1.0f, 1.0f );
-static constexpr Vector4 RED( 1.0f, 0.0f, 0.0f, 1.0f );
-static constexpr Vector4 GREEN( 0.0f, 1.0f, 0.0f, 1.0f );
-static constexpr Vector4 BLUE( 0.0f, 0.0f, 1.0f, 1.0f );
-static constexpr Vector4 YELLOW( 1.0f, 1.0f, 0.0f, 1.0f );
-static constexpr Vector4 MAGENTA( 1.0f, 0.0f, 1.0f, 1.0f );
-static constexpr Vector4 CYAN( 0.0f, 1.0f, 1.0f, 1.0f );
-static constexpr Vector4 TRANSPARENT( 0.0f, 0.0f, 0.0f, 0.0f );
+static constexpr Vector4 BLACK(0.0f, 0.0f, 0.0f, 1.0f);
+static constexpr Vector4 WHITE(1.0f, 1.0f, 1.0f, 1.0f);
+static constexpr Vector4 RED(1.0f, 0.0f, 0.0f, 1.0f);
+static constexpr Vector4 GREEN(0.0f, 1.0f, 0.0f, 1.0f);
+static constexpr Vector4 BLUE(0.0f, 0.0f, 1.0f, 1.0f);
+static constexpr Vector4 YELLOW(1.0f, 1.0f, 0.0f, 1.0f);
+static constexpr Vector4 MAGENTA(1.0f, 0.0f, 1.0f, 1.0f);
+static constexpr Vector4 CYAN(0.0f, 1.0f, 1.0f, 1.0f);
+static constexpr Vector4 TRANSPARENT(0.0f, 0.0f, 0.0f, 0.0f);
} // namespace Color
static constexpr float MACHINE_EPSILON_10000 = Epsilon<10000>::value;
// float is preferred to double for performance on ARM targets
-static constexpr float PI = static_cast<float>(M_PI); ///< Pi
-static constexpr float PI_2 = static_cast<float>(M_PI_2); ///< Pi/2
-static constexpr float PI_4 = static_cast<float>(M_PI_4); ///< Pi/4
-static constexpr float PI_OVER_180 = Dali::Math::PI/180.0f; ///< Constant used to convert degree to radian
-static constexpr float ONE80_OVER_PI = 180.0f/Dali::Math::PI; ///< Constant used to convert radian to degree
+static constexpr float PI = static_cast<float>(M_PI); ///< Pi
+static constexpr float PI_2 = static_cast<float>(M_PI_2); ///< Pi/2
+static constexpr float PI_4 = static_cast<float>(M_PI_4); ///< Pi/4
+static constexpr float PI_OVER_180 = Dali::Math::PI / 180.0f; ///< Constant used to convert degree to radian
+static constexpr float ONE80_OVER_PI = 180.0f / Dali::Math::PI; ///< Constant used to convert radian to degree
} // namespace Math
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
// EXTERNAL INCLUDES
#include <stdlib.h>
-#include <string>
#include <cstdio>
+#include <string>
#if defined(BACKTRACE_ENABLED)
#if defined(__GLIBC__)
namespace Dali
{
-
#if defined(BACKTRACE_ENABLED)
namespace
if(openParen != NULL)
{
const char* startOfToken = openParen + 1;
- const char* plus = strchr(startOfToken, '+');
- const char* closeParen = strchr(startOfToken, ')');
- const char* endOfToken = NULL;
+ const char* plus = strchr(startOfToken, '+');
+ const char* closeParen = strchr(startOfToken, ')');
+ const char* endOfToken = NULL;
if(plus != NULL)
{
endOfToken = plus;
size_t tokenLength = endOfToken - startOfToken;
// Allocate space for symbol
- char *mangledSymbol = reinterpret_cast< char* >( malloc( tokenLength + 1u ) );
+ char* mangledSymbol = reinterpret_cast<char*>(malloc(tokenLength + 1u));
if(mangledSymbol != NULL)
{
strncpy(mangledSymbol, startOfToken, tokenLength);
mangledSymbol[tokenLength] = '\0';
- size_t size;
- int32_t status;
- char* demangled=NULL;
- demangled = abi::__cxa_demangle( mangledSymbol, NULL, &size, &status );
- if( demangled != NULL )
+ size_t size;
+ int32_t status;
+ char* demangled = NULL;
+ demangled = abi::__cxa_demangle(mangledSymbol, NULL, &size, &status);
+ if(demangled != NULL)
{
result = demangled;
free(demangled); // demangle() allocates returned string, so free it
return result;
}
-DALI_CORE_API DaliException::DaliException( const char* location, const char* condition )
-: location( location ), condition( condition )
+DALI_CORE_API DaliException::DaliException(const char* location, const char* condition)
+: location(location),
+ condition(condition)
{
// Note, if a memory error has occured, then the backtrace won't work - backtrace_symbols relies on
// allocating memory.
#if defined(DEBUG_ENABLED)
fprintf(stderr, "Exception: \n%s\n thrown at %s\nSee dlog for backtrace\n", condition, location);
#else
- fprintf(stderr, "Exception: \n%s\n thrown\nSee dlog for backtrace\n", condition );
+ fprintf(stderr, "Exception: \n%s\n thrown\nSee dlog for backtrace\n", condition);
#endif
DALI_LOG_ERROR_NOFN("Backtrace:\n");
- void* frameArray[MAX_NUM_STACK_FRAMES];
- int32_t nSize = backtrace(frameArray, MAX_NUM_STACK_FRAMES);
- char** symbols = backtrace_symbols(frameArray, nSize);
- for(int32_t i=1; i< nSize; i++)
+ void* frameArray[MAX_NUM_STACK_FRAMES];
+ int32_t nSize = backtrace(frameArray, MAX_NUM_STACK_FRAMES);
+ char** symbols = backtrace_symbols(frameArray, nSize);
+ for(int32_t i = 1; i < nSize; i++)
{
std::string demangled_symbol = Demangle(symbols[i]);
- DALI_LOG_ERROR_NOFN("[%02d] %s\n", i, demangled_symbol.c_str() );
+ DALI_LOG_ERROR_NOFN("[%02d] %s\n", i, demangled_symbol.c_str());
}
free(symbols);
}
-
#else // BACKTRACE_ENABLED
-DALI_CORE_API DaliException::DaliException( const char* location, const char* condition )
-: location( location ), condition( condition )
+DALI_CORE_API DaliException::DaliException(const char* location, const char* condition)
+: location(location),
+ condition(condition)
{
#if defined(DEBUG_ENABLED)
- printf("Exception: \n%s\n thrown at %s\n", condition, location );
+ printf("Exception: \n%s\n thrown at %s\n", condition, location);
#else
- printf("Exception: \n%s\n thrown\n", condition );
+ printf("Exception: \n%s\n thrown\n", condition);
#endif
}
-
#endif // BACKTRACE_ENABLED
-DALI_CORE_API void DaliAssertMessage( const char* location, const char* condition )
+DALI_CORE_API void DaliAssertMessage(const char* location, const char* condition)
{
#if defined(DEBUG_ENABLED)
- DALI_LOG_ERROR_NOFN( "Assert (%s) failed in: %s\n", condition, location );
+ DALI_LOG_ERROR_NOFN("Assert (%s) failed in: %s\n", condition, location);
#else
- DALI_LOG_ERROR_NOFN( "Assert (%s) failed\n", condition );
+ DALI_LOG_ERROR_NOFN("Assert (%s) failed\n", condition);
#endif
}
-} // Dali
+} // namespace Dali
* When building a library that uses DALI, HIDE_DALI_INTERNALS.
*/
#if __GNUC__ >= 4
-# ifndef HIDE_DALI_INTERNALS
-# define DALI_EXPORT_API
-# define DALI_NO_EXPORT_API
-# define DALI_IMPORT_API
-# define DALI_CORE_API
-# define DALI_INTERNAL
-# else
-# define DALI_EXPORT_API __attribute__ ((visibility ("default")))
-# define DALI_NO_EXPORT_API __attribute__ ((visibility ("hidden")))
-# define DALI_IMPORT_API __attribute__ ((visibility ("default")))
-# define DALI_CORE_API __attribute__ ((visibility ("default")))
-# define DALI_INTERNAL __attribute__ ((visibility ("hidden")))
-# endif
+#ifndef HIDE_DALI_INTERNALS
+#define DALI_EXPORT_API
+#define DALI_NO_EXPORT_API
+#define DALI_IMPORT_API
+#define DALI_CORE_API
+#define DALI_INTERNAL
+#else
+#define DALI_EXPORT_API __attribute__((visibility("default")))
+#define DALI_NO_EXPORT_API __attribute__((visibility("hidden")))
+#define DALI_IMPORT_API __attribute__((visibility("default")))
+#define DALI_CORE_API __attribute__((visibility("default")))
+#define DALI_INTERNAL __attribute__((visibility("hidden")))
+#endif
#else
#ifdef WIN32
- /** Visibility attribute to show declarations */
-# define DALI_EXPORT_API __declspec(dllexport)
+/** Visibility attribute to show declarations */
+#define DALI_EXPORT_API __declspec(dllexport)
#ifdef BUILDING_DALI_CORE
- /** Visibility attribute to hide declarations */
-# define DALI_CORE_API __declspec(dllexport)
+/** Visibility attribute to hide declarations */
+#define DALI_CORE_API __declspec(dllexport)
#else
/** Visibility attribute to hide declarations */
-# define DALI_CORE_API __declspec(dllimport)
+#define DALI_CORE_API __declspec(dllimport)
#endif
#else
- /** Visibility attribute to show declarations */
-# define DALI_EXPORT_API
/** Visibility attribute to show declarations */
-# define DALI_IMPORT_API
+#define DALI_EXPORT_API
+/** Visibility attribute to show declarations */
+#define DALI_IMPORT_API
/** Visibility attribute to show declarations */
-# define DALI_CORE_API
+#define DALI_CORE_API
#endif
/** Visibility attribute to hide declarations */
-# define DALI_INTERNAL
-# define DALI_NO_EXPORT_API
+#define DALI_INTERNAL
+#define DALI_NO_EXPORT_API
#endif
#ifdef DEPRECATION_WARNING
#define DALI_DEPRECATED_API
#endif
-#if defined (__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
+#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L)
// C++0x support
#define _CPP11
#else
* @SINCE_1_0.0
*/
#ifdef __GNUC
-#define DALI_LIKELY(expression) __builtin_expect( !!(expression), 1 )
-#define DALI_UNLIKELY(expression) __builtin_expect( !!(expression), 0 )
+#define DALI_LIKELY(expression) __builtin_expect(!!(expression), 1)
+#define DALI_UNLIKELY(expression) __builtin_expect(!!(expression), 0)
#else
-#define DALI_LIKELY(expression) !!(expression)
+#define DALI_LIKELY(expression) !!(expression)
#define DALI_UNLIKELY(expression) !!(expression)
#endif
* @param[in] location Where the assertion occurred
* @param[in] condition The assertion condition
*/
-DALI_CORE_API void DaliAssertMessage( const char* location, const char* condition );
+DALI_CORE_API void DaliAssertMessage(const char* location, const char* condition);
/**
* @brief Exception class for Dali Core library - Raised by assertions in codebase.
* @param[in] location The location of the assertion
* @param[in] condition The assertion condition
*/
- DaliException( const char* location, const char* condition );
+ DaliException(const char* location, const char* condition);
const char* location;
const char* condition;
/**
* @}
*/
-}// Dali
+} // namespace Dali
/**
* @brief An invariant concurrent assertion to ensure its argument always evaluates TRUE.
#define ASSERT_LOCATION NULL
#endif
-#define DALI_ASSERT_ALWAYS(cond) \
- if(DALI_UNLIKELY(!(cond))) \
- { \
- Dali::DaliAssertMessage( ASSERT_LOCATION, #cond ); \
- throw Dali::DaliException( ASSERT_LOCATION, #cond ); \
+#define DALI_ASSERT_ALWAYS(cond) \
+ if(DALI_UNLIKELY(!(cond))) \
+ { \
+ Dali::DaliAssertMessage(ASSERT_LOCATION, #cond); \
+ throw Dali::DaliException(ASSERT_LOCATION, #cond); \
}
-#define DALI_ABORT(message) \
- { \
- Dali::DaliAssertMessage( ASSERT_LOCATION, message ); \
- throw Dali::DaliException( ASSERT_LOCATION, message ); \
+#define DALI_ABORT(message) \
+ { \
+ Dali::DaliAssertMessage(ASSERT_LOCATION, message); \
+ throw Dali::DaliException(ASSERT_LOCATION, message); \
}
/**
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
VectorBase::VectorBase()
- : mData( NULL )
+: mData(nullptr)
{
}
VectorBase::SizeType VectorBase::Capacity() const
{
SizeType capacity = 0u;
- if( mData )
+ if(mData)
{
- SizeType* metadata = reinterpret_cast< SizeType* >( mData );
- capacity = *(metadata - 2u);
+ SizeType* metadata = reinterpret_cast<SizeType*>(mData);
+ capacity = *(metadata - 2u);
}
return capacity;
}
-
void VectorBase::Release()
{
- if( mData )
+ if(mData)
{
// adjust pointer to real beginning
- SizeType* metadata = reinterpret_cast< SizeType* >( mData );
+ SizeType* metadata = reinterpret_cast<SizeType*>(mData);
- delete [] ( metadata - 2u );
- mData = 0u;
+ delete[](metadata - 2u);
+ mData = nullptr;
}
}
-void VectorBase::SetCount( SizeType count )
+void VectorBase::SetCount(SizeType count)
{
// someone can call Resize( 0u ) before ever populating the vector
- if( mData )
+ if(mData)
{
- SizeType* metadata = reinterpret_cast< SizeType* >( mData );
- *(metadata - 1u) = count;
+ SizeType* metadata = reinterpret_cast<SizeType*>(mData);
+ *(metadata - 1u) = count;
}
}
-void VectorBase::Reserve( SizeType capacity, SizeType elementSize )
+void VectorBase::Reserve(SizeType capacity, SizeType elementSize)
{
SizeType oldCapacity = Capacity();
- SizeType oldCount = Count();
- if( capacity > oldCapacity )
+ SizeType oldCount = Count();
+ if(capacity > oldCapacity)
{
const SizeType wholeAllocation = sizeof(SizeType) * 2u + capacity * elementSize;
- void* wholeData = reinterpret_cast< void* >( new uint8_t[ wholeAllocation ] );
- DALI_ASSERT_ALWAYS( wholeData && "VectorBase::Reserve - Memory allocation failed" );
+ void* wholeData = reinterpret_cast<void*>(new uint8_t[wholeAllocation]);
+ DALI_ASSERT_ALWAYS(wholeData && "VectorBase::Reserve - Memory allocation failed");
-#if defined( DEBUG_ENABLED )
+#if defined(DEBUG_ENABLED)
// in debug build this will help identify a vector of uninitialized data
- memset( wholeData, 0xaa, wholeAllocation );
+ memset(wholeData, 0xaa, wholeAllocation);
#endif
- SizeType* metaData = reinterpret_cast< SizeType* >( wholeData );
- *metaData++ = capacity;
- *metaData++ = oldCount;
- if( mData )
+ SizeType* metaData = reinterpret_cast<SizeType*>(wholeData);
+ *metaData++ = capacity;
+ *metaData++ = oldCount;
+ if(mData)
{
// copy over the old data
- memcpy( metaData, mData, oldCount * elementSize );
+ memcpy(metaData, mData, oldCount * elementSize);
// release old buffer
Release();
}
}
}
-void VectorBase::Copy( const VectorBase& vector, SizeType elementSize )
+void VectorBase::Copy(const VectorBase& vector, SizeType elementSize)
{
// release old data
Release();
// reserve space based on source capacity
const SizeType capacity = vector.Capacity();
- Reserve( capacity, elementSize );
+ Reserve(capacity, elementSize);
// copy over whole data
const SizeType wholeAllocation = sizeof(SizeType) * 2u + capacity * elementSize;
- SizeType* srcData = reinterpret_cast< SizeType* >( vector.mData );
- SizeType* dstData = reinterpret_cast< SizeType* >( mData );
- memcpy( dstData - 2u, srcData - 2u, wholeAllocation );
+ SizeType* srcData = reinterpret_cast<SizeType*>(vector.mData);
+ SizeType* dstData = reinterpret_cast<SizeType*>(mData);
+ memcpy(dstData - 2u, srcData - 2u, wholeAllocation);
}
-void VectorBase::Swap( VectorBase& vector )
+void VectorBase::Swap(VectorBase& vector)
{
// just swap the data pointers, metadata will swap as side effect
- std::swap( mData, vector.mData );
+ std::swap(mData, vector.mData);
}
-void VectorBase::Erase( char* address, SizeType elementSize )
+void VectorBase::Erase(char* address, SizeType elementSize)
{
// erase can be called on an unallocated vector
- if( mData )
+ if(mData)
{
- uint8_t* startAddress = reinterpret_cast< uint8_t* >( address ) + elementSize;
- const uint8_t* endAddress = reinterpret_cast< uint8_t* >( mData ) + Count() * elementSize;
- SizeType numberOfBytes = endAddress - startAddress;
+ uint8_t* startAddress = reinterpret_cast<uint8_t*>(address) + elementSize;
+ const uint8_t* endAddress = reinterpret_cast<uint8_t*>(mData) + Count() * elementSize;
+ SizeType numberOfBytes = endAddress - startAddress;
// addresses overlap so use memmove
- memmove( address, startAddress, numberOfBytes );
- SetCount( Count() - 1u );
+ memmove(address, startAddress, numberOfBytes);
+ SetCount(Count() - 1u);
}
}
-char* VectorBase::Erase( char* first, char* last, SizeType elementSize )
+char* VectorBase::Erase(char* first, char* last, SizeType elementSize)
{
- char* next = NULL;
+ char* next = nullptr;
- if( mData )
+ if(mData)
{
- uint8_t* startAddress = reinterpret_cast< uint8_t* >( last );
- const uint8_t* endAddress = reinterpret_cast< uint8_t* >( mData ) + Count() * elementSize;
- SizeType numberOfBytes = endAddress - startAddress;
+ uint8_t* startAddress = reinterpret_cast<uint8_t*>(last);
+ const uint8_t* endAddress = reinterpret_cast<uint8_t*>(mData) + Count() * elementSize;
+ SizeType numberOfBytes = endAddress - startAddress;
// addresses overlap so use memmove
- memmove( first, startAddress, numberOfBytes );
- SetCount( Count() - ( last - first ) / elementSize );
+ memmove(first, startAddress, numberOfBytes);
+ SetCount(Count() - (last - first) / elementSize);
next = first;
}
return next;
}
-void VectorBase::CopyMemory( char* destination, const char* source, size_t numberOfBytes )
+void VectorBase::CopyMemory(char* destination, const char* source, size_t numberOfBytes)
{
- if( ( ( source < destination ) && ( source + numberOfBytes > destination ) ) ||
- ( ( destination < source ) && ( destination + numberOfBytes > source ) ) )
+ if(((source < destination) && (source + numberOfBytes > destination)) ||
+ ((destination < source) && (destination + numberOfBytes > source)))
{
// If there is overlap, use memmove.
- memmove( destination, source, numberOfBytes );
+ memmove(destination, source, numberOfBytes);
}
else
{
// It's safe to use memcpy if there isn't overlap.
- memcpy( destination, source, numberOfBytes );
+ memcpy(destination, source, numberOfBytes);
}
}
} // namespace Dali
-
*/
// EXTERNAL INCLUDES
-#include <cstddef>
#include <algorithm>
+#include <cstddef>
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
* For Application use, asserts can be enabled manually.
* @SINCE_1_0.0
*/
-#if defined( DEBUG_ENABLED )
+#if defined(DEBUG_ENABLED)
#define ENABLE_VECTOR_ASSERTS
#endif
-#if defined( ENABLE_VECTOR_ASSERTS )
+#if defined(ENABLE_VECTOR_ASSERTS)
#define DALI_ASSERT_VECTOR(cond) DALI_ASSERT_ALWAYS(cond)
#else
#define DALI_ASSERT_VECTOR(cond)
class DALI_CORE_API VectorBase
{
public: // Typedefs
-
- typedef std::size_t SizeType;
+ using SizeType = std::size_t;
protected: // Construction
-
/**
* @brief Default constructor. Does not allocate space.
* @SINCE_1_0.0
~VectorBase();
public: // API
-
/**
* @brief This method is inlined as it's needed frequently for Vector::End() iterator.
*
SizeType Count() const
{
SizeType items = 0u;
- if( mData )
+ if(mData)
{
- SizeType* metadata = reinterpret_cast< SizeType* >( mData );
- items = *(metadata - 1u);
+ SizeType* metadata = reinterpret_cast<SizeType*>(mData);
+ items = *(metadata - 1u);
}
return items;
}
void Release();
protected: // for Derived classes
-
/**
* @brief Helper to set the count.
*
* @SINCE_1_0.0
* @param[in] count Number of elements in the vector
*/
- void SetCount( SizeType count );
+ void SetCount(SizeType count);
/**
* @brief Reserves space in the vector.
* @param[in] count Count of elements to reserve
* @param[in] elementSize Size of a single element
*/
- void Reserve( SizeType count, SizeType elementSize );
+ void Reserve(SizeType count, SizeType elementSize);
/**
* @brief Copy a vector.
* @param[in] vector Vector to copy from
* @param[in] elementSize Size of a single element
*/
- void Copy( const VectorBase& vector, SizeType elementSize );
+ void Copy(const VectorBase& vector, SizeType elementSize);
/**
* @brief Swaps the contents of two vectors.
* @SINCE_1_0.0
* @param[in] vector Vector to swap with
*/
- void Swap( VectorBase& vector );
+ void Swap(VectorBase& vector);
/**
* @brief Erases an element.
* @param[in] elementSize Size to erase
* @pre Last element cannot be erased as there is nothing to move.
*/
- void Erase( char* address, SizeType elementSize );
+ void Erase(char* address, SizeType elementSize);
/**
* @brief Erases a range of elements.
* @param[in] elementSize Size of one of the elements to be erased
* @return Address pointing to the next element of the last one
*/
- char* Erase( char* first, char* last, SizeType elementSize );
+ char* Erase(char* first, char* last, SizeType elementSize);
/**
* @brief Copies a number of bytes from \e source to \e destination.
* @param[in] source Pointer to the source address
* @param[in] numberOfBytes The number of bytes to be copied
*/
- void CopyMemory( char* destination, const char* source, size_t numberOfBytes );
+ void CopyMemory(char* destination, const char* source, size_t numberOfBytes);
private:
-
// not copyable as it does not know the size of elements
- VectorBase( const VectorBase& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- VectorBase& operator=( const VectorBase& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ VectorBase(const VectorBase&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ VectorBase& operator=(const VectorBase&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
// not movable as this is handled by deriving classes
- VectorBase( VectorBase&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- VectorBase& operator=( VectorBase&& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_9.25
-
-protected: // Data
+ VectorBase(VectorBase&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ VectorBase& operator=(VectorBase&&) = delete; ///< Deleted copy assignment operator. @SINCE_1_9.25
+protected: // Data
void* mData; ///< Pointer to the data.
-
};
/// @cond internal
* Trivial types do not need destructor or copy constructor called.
* @SINCE_1_0.0
*/
-template< bool IsTrivial >
+template<bool IsTrivial>
class VectorAlgorithms : public VectorBase
{
protected: // API for deriving classes
-
- typedef VectorBase::SizeType SizeType;
+ using SizeType = VectorBase::SizeType;
/**
* @brief Empty constructor.
* @SINCE_1_0.0
*/
VectorAlgorithms()
- { }
+ {
+ }
/**
* @brief Empty destructor.
* @SINCE_1_0.0
*/
~VectorAlgorithms()
- { }
+ {
+ }
/**
* @brief Copy vector contents.
* @param[in] rhs VectorBase object to copy from
* @param[in] elementSize Size of the content
*/
- void Copy( const VectorBase& rhs, SizeType elementSize )
+ void Copy(const VectorBase& rhs, SizeType elementSize)
{
- if( rhs.Capacity() > 0u )
+ if(rhs.Capacity() > 0u)
{
- VectorBase::Copy( rhs, elementSize );
+ VectorBase::Copy(rhs, elementSize);
}
else
{
* @param[in] count Count of elements to reserve
* @param[in] elementSize Size of a single element
*/
- void Reserve( SizeType count, SizeType elementSize )
+ void Reserve(SizeType count, SizeType elementSize)
{
- VectorBase::Reserve( count, elementSize );
+ VectorBase::Reserve(count, elementSize);
}
/**
* @param[in] count Count to resize to
* @param[in] elementSize Size of a single element
*/
- void Resize( SizeType count, SizeType elementSize )
+ void Resize(SizeType count, SizeType elementSize)
{
// reserve will copy old elements as well
- Reserve( count, elementSize );
+ Reserve(count, elementSize);
}
/**
*/
void Clear()
{
- if( mData )
+ if(mData)
{
- VectorBase::SetCount( 0u );
+ VectorBase::SetCount(0u);
}
}
* @param[in] address Address to erase from
* @param[in] elementSize Size to erase
*/
- void Erase( uint8_t* address, SizeType elementSize )
+ void Erase(uint8_t* address, SizeType elementSize)
{
- VectorBase::Erase( reinterpret_cast< char* >( address ), elementSize );
+ VectorBase::Erase(reinterpret_cast<char*>(address), elementSize);
}
/**
* @param[in] elementSize Size of one of the elements to be erased
* @return Address pointing to the next element of the last one
*/
- uint8_t* Erase( uint8_t* first, uint8_t* last, SizeType elementSize )
+ uint8_t* Erase(uint8_t* first, uint8_t* last, SizeType elementSize)
{
- return reinterpret_cast< uint8_t* >( VectorBase::Erase( reinterpret_cast< char* >( first ), reinterpret_cast< char *>( last ), elementSize ) );
+ return reinterpret_cast<uint8_t*>(VectorBase::Erase(reinterpret_cast<char*>(first), reinterpret_cast<char*>(last), elementSize));
}
/**
* @param[in] to Address to the last element to be inserted
* @param[in] elementSize Size of one of the elements to be inserted
*/
- void Insert( uint8_t* at, uint8_t* from, uint8_t* to, SizeType elementSize )
+ void Insert(uint8_t* at, uint8_t* from, uint8_t* to, SizeType elementSize)
{
- const SizeType size = to - from;
- const SizeType count = Count();
+ const SizeType size = to - from;
+ const SizeType count = Count();
const SizeType newCount = count + size / elementSize;
- if( newCount > Capacity() )
+ if(newCount > Capacity())
{
// Calculate the at offset as the pointer is invalid after the Reserve() call.
- std::size_t offset = at - reinterpret_cast<uint8_t*>( mData );
+ std::size_t offset = at - reinterpret_cast<uint8_t*>(mData);
// need more space
- Reserve( NextPowerOfTwo( static_cast<uint32_t>( newCount ) ), elementSize ); // reserve enough space to store at least the next power of two elements of the new required size.
+ Reserve(NextPowerOfTwo(static_cast<uint32_t>(newCount)), elementSize); // reserve enough space to store at least the next power of two elements of the new required size.
// Set the new at pointer.
- at = reinterpret_cast<uint8_t*>( mData ) + offset;
+ at = reinterpret_cast<uint8_t*>(mData) + offset;
}
// set new count first as otherwise the debug assert will hit us
- SetCount( newCount );
+ SetCount(newCount);
// Move current items to a new position inside the vector.
- CopyMemory( reinterpret_cast< char* >( at + size ),
- reinterpret_cast< const char* >( at ),
- ( reinterpret_cast<uint8_t*>( mData ) + count * elementSize ) - at );
+ CopyMemory(reinterpret_cast<char*>(at + size),
+ reinterpret_cast<const char*>(at),
+ (reinterpret_cast<uint8_t*>(mData) + count * elementSize) - at);
// Copy the given items.
- CopyMemory( reinterpret_cast< char* >( at ), reinterpret_cast< const char* >( from ), size );
+ CopyMemory(reinterpret_cast<char*>(at), reinterpret_cast<const char*>(from), size);
}
};
/// @endcond
* @SINCE_1_0.0
*/
template<>
-class VectorAlgorithms< false > : public VectorBase
+class VectorAlgorithms<false> : public VectorBase
{
private:
VectorAlgorithms()
- { }
+ {
+ }
~VectorAlgorithms()
- { }
+ {
+ }
};
/// @endcond
* @SINCE_1_0.0
* @param type The type of the data that the vector holds
*/
-template< class T, bool IsTrivialType = TypeTraits<T>::IS_TRIVIAL_TYPE == true >
-class Vector : public VectorAlgorithms< IsTrivialType >
+template<class T, bool IsTrivialType = TypeTraits<T>::IS_TRIVIAL_TYPE == true>
+class Vector : public VectorAlgorithms<IsTrivialType>
{
public: // API
-
/**
* @brief Type definitions.
* @SINCE_1_0.0
*/
- typedef VectorBase::SizeType SizeType; ///< Size type @SINCE_1_0.0
- typedef T* Iterator; ///< Most simple Iterator is a pointer @SINCE_1_0.0
- typedef const T* ConstIterator; ///< Const iterator @SINCE_1_0.0
- typedef T ItemType; ///< Item type @SINCE_1_0.0
+ using SizeType = VectorBase::SizeType; ///< Size type @SINCE_1_0.0
+ using Iterator = T*; ///< Most simple Iterator is a pointer @SINCE_1_0.0
+ using ConstIterator = const T*; ///< Const iterator @SINCE_1_0.0
+ using ItemType = T; ///< Item type @SINCE_1_0.0
/**
* @brief Enumeration for BaseType.
* @SINCE_1_0.0
*/
Vector()
- { }
+ {
+ }
/**
* @brief Destructor. Releases the allocated space.
* @SINCE_1_0.0
* @param[in] vector Vector to copy from
*/
- Vector( const Vector& vector )
+ Vector(const Vector& vector)
{
// reuse copy assignment
- operator=( vector );
+ operator=(vector);
}
/**
* @SINCE_1_9.25
* @param[in] vector Vector to move
*/
- Vector( Vector&& vector )
+ Vector(Vector&& vector)
{
// reuse move assignment
- operator=( std::move( vector ) );
+ operator=(std::move(vector));
}
/**
* @param[in] vector Vector to assign from
* @return Reference to self for chaining
*/
- Vector& operator=( const Vector& vector )
+ Vector& operator=(const Vector& vector)
{
- if( this != &vector )
+ if(this != &vector)
{
- VectorAlgorithms<BaseType>::Copy( vector, sizeof( ItemType ) );
+ VectorAlgorithms<BaseType>::Copy(vector, sizeof(ItemType));
}
return *this;
}
* @SINCE_1_9.25
* @param[in] vector Vector to move
*/
- Vector& operator=( Vector&& vector )
+ Vector& operator=(Vector&& vector)
{
- if( this != &vector )
+ if(this != &vector)
{
- if( VectorBase::mData )
+ if(VectorBase::mData)
{
Release();
}
VectorBase::mData = vector.mData;
- vector.mData = nullptr;
+ vector.mData = nullptr;
}
return *this;
}
*/
Iterator Begin() const
{
- ItemType* address = reinterpret_cast<ItemType*>( VectorBase::mData );
+ ItemType* address = reinterpret_cast<ItemType*>(VectorBase::mData);
return address;
}
*/
Iterator End() const
{
- ItemType* address = reinterpret_cast<ItemType*>( VectorBase::mData );
+ ItemType* address = reinterpret_cast<ItemType*>(VectorBase::mData);
address += VectorBase::Count();
return address;
}
* @return Reference to the element for given index
* @pre Index must be in the vector's range.
*/
- ItemType& operator[]( SizeType index )
+ ItemType& operator[](SizeType index)
{
// reuse the const version
- return const_cast< ItemType& >( const_cast< const Vector< ItemType >& >( *this )[ index ] );
+ return const_cast<ItemType&>(const_cast<const Vector<ItemType>&>(*this)[index]);
}
/**
* @return Reference to the element for given index
* @pre Index must be in the vector's range.
*/
- const ItemType& operator[]( SizeType index ) const
+ const ItemType& operator[](SizeType index) const
{
- DALI_ASSERT_VECTOR( VectorBase::mData && "Vector is empty" );
- DALI_ASSERT_VECTOR( index < VectorBase::Count() && "Index out of bounds" );
- ItemType* address = reinterpret_cast<ItemType*>( VectorBase::mData );
+ DALI_ASSERT_VECTOR(VectorBase::mData && "Vector is empty");
+ DALI_ASSERT_VECTOR(index < VectorBase::Count() && "Index out of bounds");
+ ItemType* address = reinterpret_cast<ItemType*>(VectorBase::mData);
address += index;
return *address;
}
* @SINCE_1_0.0
* @param[in] element Element to be added
*/
- void PushBack( const ItemType& element )
+ void PushBack(const ItemType& element)
{
- const SizeType count = VectorBase::Count();
+ const SizeType count = VectorBase::Count();
const SizeType newCount = count + 1u;
const SizeType capacity = VectorBase::Capacity();
- if( newCount > capacity )
+ if(newCount > capacity)
{
// need more space
- Reserve( newCount << 1u ); // reserve double the current count
+ Reserve(newCount << 1u); // reserve double the current count
}
// set new count first as otherwise the debug assert will hit us
- VectorBase::SetCount( newCount );
- operator[]( count ) = element;
+ VectorBase::SetCount(newCount);
+ operator[](count) = element;
}
/**
* @param[in] element An element to be added
* @pre Iterator at must be in the vector's range ( Vector::Begin(), Vector::End() ).
*/
- void Insert( Iterator at, const ItemType& element )
+ void Insert(Iterator at, const ItemType& element)
{
- DALI_ASSERT_VECTOR( ( at <= End() ) && ( at >= Begin() ) && "Iterator not inside vector" );
- const SizeType size = sizeof( ItemType );
- uint8_t* address = const_cast<uint8_t*>( reinterpret_cast<const uint8_t*>( &element ) );
- VectorAlgorithms<BaseType>::Insert( reinterpret_cast< uint8_t* >( at ),
- address,
- address + size,
- size );
+ DALI_ASSERT_VECTOR((at <= End()) && (at >= Begin()) && "Iterator not inside vector");
+ const SizeType size = sizeof(ItemType);
+ uint8_t* address = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&element));
+ VectorAlgorithms<BaseType>::Insert(reinterpret_cast<uint8_t*>(at),
+ address,
+ address + size,
+ size);
}
/**
* @pre Iterator \e from must not be grater than Iterator \e to.
*
*/
- void Insert( Iterator at, Iterator from, Iterator to )
+ void Insert(Iterator at, Iterator from, Iterator to)
{
- DALI_ASSERT_VECTOR( ( at <= End() ) && ( at >= Begin() ) && "Iterator not inside vector" );
- DALI_ASSERT_VECTOR( ( from <= to ) && "from address can't be greater than to" );
+ DALI_ASSERT_VECTOR((at <= End()) && (at >= Begin()) && "Iterator not inside vector");
+ DALI_ASSERT_VECTOR((from <= to) && "from address can't be greater than to");
- if( from == to )
+ if(from == to)
{
// nothing to copy.
return;
}
- VectorAlgorithms<BaseType>::Insert( reinterpret_cast< uint8_t* >( at ),
- reinterpret_cast< uint8_t* >( from ),
- reinterpret_cast< uint8_t* >( to ),
- sizeof( ItemType ) );
+ VectorAlgorithms<BaseType>::Insert(reinterpret_cast<uint8_t*>(at),
+ reinterpret_cast<uint8_t*>(from),
+ reinterpret_cast<uint8_t*>(to),
+ sizeof(ItemType));
}
/**
* @SINCE_1_0.0
* @param[in] count Count of elements to reserve
*/
- void Reserve( SizeType count )
+ void Reserve(SizeType count)
{
- VectorAlgorithms<BaseType>::Reserve( count, sizeof( ItemType ) );
+ VectorAlgorithms<BaseType>::Reserve(count, sizeof(ItemType));
}
/**
* @SINCE_1_0.0
* @param[in] count Count to resize to
*/
- void Resize( SizeType count )
+ void Resize(SizeType count)
{
ItemType item = ItemType();
Resize(count, item);
* @SINCE_1_9.27
* @param[in] count Count to resize to
*/
- void ResizeUninitialized( SizeType count )
+ void ResizeUninitialized(SizeType count)
{
- Reserve( count );
- VectorBase::SetCount( count );
+ Reserve(count);
+ VectorBase::SetCount(count);
}
/**
* @param[in] count Count to resize to
* @param[in] item An item to insert to the new indices
*/
- void Resize( SizeType count, const ItemType& item )
+ void Resize(SizeType count, const ItemType& item)
{
const SizeType oldCount = VectorBase::Count();
- if( count <= oldCount )
+ if(count <= oldCount)
{
// getting smaller so just set count
- VectorBase::SetCount( count );
+ VectorBase::SetCount(count);
}
else
{
// remember how many new items get added
SizeType newItems = count - oldCount;
- Reserve( count );
- for( ; newItems > 0u; --newItems )
+ Reserve(count);
+ for(; newItems > 0u; --newItems)
{
- PushBack( item );
+ PushBack(item);
}
}
}
* @pre Iterator \e iterator must be within the vector's range ( Vector::Begin(), Vector::End() - 1 ).
*
*/
- Iterator Erase( Iterator iterator )
+ Iterator Erase(Iterator iterator)
{
- DALI_ASSERT_VECTOR( (iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector" );
- if( iterator < ( End() - 1u ) )
+ DALI_ASSERT_VECTOR((iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector");
+ if(iterator < (End() - 1u))
{
- VectorAlgorithms<BaseType>::Erase( reinterpret_cast< uint8_t* >( iterator ), sizeof( ItemType ) );
+ VectorAlgorithms<BaseType>::Erase(reinterpret_cast<uint8_t*>(iterator), sizeof(ItemType));
}
else
{
// just remove the element
- Remove( iterator );
+ Remove(iterator);
}
return iterator;
}
* @pre Iterator \e first must not be grater than Iterator \e last.
*
*/
- Iterator Erase( Iterator first, Iterator last )
+ Iterator Erase(Iterator first, Iterator last)
{
- DALI_ASSERT_VECTOR( ( first <= End() ) && ( first >= Begin() ) && "Iterator not inside vector" );
- DALI_ASSERT_VECTOR( ( last <= End() ) && ( last >= Begin() ) && "Iterator not inside vector" );
- DALI_ASSERT_VECTOR( ( first <= last ) && "first iterator greater than last" );
+ DALI_ASSERT_VECTOR((first <= End()) && (first >= Begin()) && "Iterator not inside vector");
+ DALI_ASSERT_VECTOR((last <= End()) && (last >= Begin()) && "Iterator not inside vector");
+ DALI_ASSERT_VECTOR((first <= last) && "first iterator greater than last");
Iterator nextElement;
- if( last == End() )
+ if(last == End())
{
// Erase up to the end.
- VectorBase::SetCount( VectorBase::Count() - ( last - first ) );
+ VectorBase::SetCount(VectorBase::Count() - (last - first));
nextElement = End();
}
else
{
- nextElement = reinterpret_cast<Iterator>( VectorAlgorithms<BaseType>::Erase( reinterpret_cast< uint8_t* >( first ),
- reinterpret_cast< uint8_t* >( last ),
- sizeof( ItemType ) ) );
+ nextElement = reinterpret_cast<Iterator>(VectorAlgorithms<BaseType>::Erase(reinterpret_cast<uint8_t*>(first),
+ reinterpret_cast<uint8_t*>(last),
+ sizeof(ItemType)));
}
return nextElement;
* @pre Iterator \e iterator must be in the vector's range ( Vector::Begin(), Vector::End() - 1 ).
*
*/
- void Remove( Iterator iterator )
+ void Remove(Iterator iterator)
{
- DALI_ASSERT_VECTOR( (iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector" );
+ DALI_ASSERT_VECTOR((iterator < End()) && (iterator >= Begin()) && "Iterator not inside vector");
Iterator last = End() - 1u;
- if( last > iterator )
+ if(last > iterator)
{
- std::swap( *iterator, *last );
+ std::swap(*iterator, *last);
}
- VectorBase::SetCount( VectorBase::Count() - 1u );
+ VectorBase::SetCount(VectorBase::Count() - 1u);
}
/**
* @SINCE_1_0.0
* @param[in] vector Vector to swap with
*/
- void Swap( Vector& vector )
+ void Swap(Vector& vector)
{
- VectorBase::Swap( vector );
+ VectorBase::Swap(vector);
}
/**
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
Extents::Extents()
: start(0),
end(0),
top(0),
bottom(0)
- {
- }
+{
+}
-Extents::Extents( uint16_t start, uint16_t end, uint16_t top, uint16_t bottom )
-: start( start ),
- end( end ),
- top( top ),
- bottom( bottom )
- {
- }
+Extents::Extents(uint16_t start, uint16_t end, uint16_t top, uint16_t bottom)
+: start(start),
+ end(end),
+ top(top),
+ bottom(bottom)
+{
+}
-Extents& Extents::operator=( const uint16_t* array )
+Extents& Extents::operator=(const uint16_t* array)
{
- start = array[0];
- end = array[1];
- top = array[2];
+ start = array[0];
+ end = array[1];
+ top = array[2];
bottom = array[3];
return *this;
}
-bool Extents::operator==( const Extents &rhs ) const
+bool Extents::operator==(const Extents& rhs) const
{
- return ( start == rhs.start )&&
- ( end == rhs.end )&&
- ( top == rhs.top )&&
- ( bottom == rhs.bottom );
+ return (start == rhs.start) &&
+ (end == rhs.end) &&
+ (top == rhs.top) &&
+ (bottom == rhs.bottom);
}
-bool Extents::operator!=( const Extents &rhs ) const
+bool Extents::operator!=(const Extents& rhs) const
{
- return !( *this == rhs );
+ return !(*this == rhs);
}
-std::ostream& operator<<( std::ostream& stream, const Extents& extents )
+std::ostream& operator<<(std::ostream& stream, const Extents& extents)
{
return stream << "[" << extents.start << ", " << extents.end << ", " << extents.top << ", " << extents.bottom << "]";
}
-} // Dali
+} // namespace Dali
#define DALI_EXTENTS_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* @SINCE_1_2.62
* @param[in] copy A reference to the copied Extents
*/
- Extents( const Extents& copy ) = default;
+ Extents(const Extents& copy) = default;
/**
* @brief Constructor.
* @param[in] top Top extent
* @param[in] bottom Bottom extent
*/
- Extents( uint16_t start, uint16_t end, uint16_t top, uint16_t bottom );
+ Extents(uint16_t start, uint16_t end, uint16_t top, uint16_t bottom);
/**
* @brief Copy Assignment operator.
* @param[in] copy A reference to the copied Extents
* @return Itself
*/
- Extents& operator=( const Extents& copy ) = default;
+ Extents& operator=(const Extents& copy) = default;
/**
* @brief Assignment operator.
* @param[in] array Array of uint16_t
* @return Itself
*/
- Extents& operator=( const uint16_t* array );
+ Extents& operator=(const uint16_t* array);
/**
* @brief Equality operator.
* @param[in] rhs The Extents to test against
* @return True if the extents are equal
*/
- bool operator==( const Extents &rhs ) const;
+ bool operator==(const Extents& rhs) const;
/**
* @brief Inequality operator.
* @param[in] rhs The Extents to test against
* @return True if the extents are not equal
*/
- bool operator!=( const Extents &rhs ) const;
+ bool operator!=(const Extents& rhs) const;
public:
- uint16_t start; ///< The start extent. @SINCE_1_2.62
- uint16_t end; ///< The end extent. @SINCE_1_2.62
- uint16_t top; ///< The top extent. @SINCE_1_2.62
- uint16_t bottom; ///< The bottom extent. @SINCE_1_2.62
-
+ uint16_t start; ///< The start extent. @SINCE_1_2.62
+ uint16_t end; ///< The end extent. @SINCE_1_2.62
+ uint16_t top; ///< The top extent. @SINCE_1_2.62
+ uint16_t bottom; ///< The bottom extent. @SINCE_1_2.62
};
/**
* @param[in] extents The Extents to output
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Extents& extents );
+DALI_CORE_API std::ostream& operator<<(std::ostream& stream, const Extents& extents);
/**
* @}
template<typename T>
class IntrusivePtr
{
-
public:
-
/**
* @brief Standard constructor to unassigned object.
* @SINCE_1_0.0
*/
- IntrusivePtr() : mPtr( 0 ) {}
+ IntrusivePtr()
+ : mPtr(nullptr)
+ {
+ }
/**
* @brief Constructor to attach existing object.
* @SINCE_1_0.0
* @param[in] p Pointer to object
*/
- IntrusivePtr( T* p ) : mPtr( p )
+ IntrusivePtr(T* p)
+ : mPtr(p)
{
- if( mPtr )
+ if(mPtr)
{
mPtr->Reference();
}
* @tparam U Reference counter object type
*/
template<typename U>
- IntrusivePtr( IntrusivePtr<U> const& rhs ) : mPtr( rhs.Get() )
+ IntrusivePtr(IntrusivePtr<U> const& rhs)
+ : mPtr(rhs.Get())
{
- if( mPtr )
+ if(mPtr)
{
mPtr->Reference();
}
* @SINCE_1_0.0
* @param[in] rhs Const reference to an IntrusivePtr
*/
- IntrusivePtr( IntrusivePtr const& rhs ) : mPtr( rhs.mPtr )
+ IntrusivePtr(IntrusivePtr const& rhs)
+ : mPtr(rhs.mPtr)
{
- if( mPtr )
+ if(mPtr)
{
mPtr->Reference();
}
* @param[in] rhs Reference to an IntrusivePtr
*/
template<typename U>
- IntrusivePtr( IntrusivePtr<U>&& rhs )
- : mPtr( rhs.Detach() )
+ IntrusivePtr(IntrusivePtr<U>&& rhs)
+ : mPtr(rhs.Detach())
{
}
* @SINCE_1_9.23
* @param[in] rhs Reference to an IntrusivePtr
*/
- IntrusivePtr( IntrusivePtr&& rhs )
- : mPtr( rhs.Detach() )
+ IntrusivePtr(IntrusivePtr&& rhs)
+ : mPtr(rhs.Detach())
{
}
*/
~IntrusivePtr()
{
- if( mPtr )
+ if(mPtr)
{
mPtr->Unreference();
}
* @param rhs Const reference to intrusive pointer
* @return Reference to reference counted object
*/
- IntrusivePtr& operator=( IntrusivePtr const& rhs )
+ IntrusivePtr& operator=(IntrusivePtr const& rhs)
{
- IntrusivePtr( rhs ).Swap( *this );
+ IntrusivePtr(rhs).Swap(*this);
return *this;
}
* @param rhs Pointer to object to wrap
* @return A Reference to this object
*/
- IntrusivePtr& operator=( T* rhs )
+ IntrusivePtr& operator=(T* rhs)
{
- IntrusivePtr( rhs ).Swap( *this );
+ IntrusivePtr(rhs).Swap(*this);
return *this;
}
* @param rhs Reference to intrusive pointer
* @return Reference to moved intrusive pointer
*/
- IntrusivePtr& operator=( IntrusivePtr&& rhs )
+ IntrusivePtr& operator=(IntrusivePtr&& rhs)
{
- if ( this != &rhs )
+ if(this != &rhs)
{
- if (mPtr)
+ if(mPtr)
{
mPtr->Unreference();
}
* @return Reference to moved intrusive pointer
*/
template<typename U>
- IntrusivePtr& operator=( IntrusivePtr<U>&& rhs )
+ IntrusivePtr& operator=(IntrusivePtr<U>&& rhs)
{
- if ( this != reinterpret_cast<IntrusivePtr<T>*>( &rhs ) )
+ if(this != reinterpret_cast<IntrusivePtr<T>*>(&rhs))
{
- if (mPtr)
+ if(mPtr)
{
mPtr->Unreference();
}
*/
void Reset()
{
- IntrusivePtr().Swap( *this );
+ IntrusivePtr().Swap(*this);
}
/**
* @SINCE_1_0.0
* @param[in] rhs Pointer to object
*/
- void Reset( T* rhs )
+ void Reset(T* rhs)
{
- IntrusivePtr( rhs ).Swap( *this );
+ IntrusivePtr(rhs).Swap(*this);
}
// IntrusivePtr comparisons - This is a variation of the safe bool idiom
*
* Objects can be implicitly converted to this for validity checks.
*/
- typedef void (IntrusivePtr::*BooleanType)() const;
+ using BooleanType = void (IntrusivePtr<T>::*)() const;
/**
* @brief Converts an object handle to a BooleanType.
*/
operator BooleanType() const
{
- return mPtr ? &IntrusivePtr::ThisIsSaferThanReturningVoidStar : 0;
+ return mPtr ? &IntrusivePtr::ThisIsSaferThanReturningVoidStar : nullptr;
}
/**
T* Detach()
{
T* ptr = mPtr;
- mPtr = 0;
+ mPtr = nullptr;
return ptr;
}
private:
-
/**
* @brief Used by the safe bool idiom.
* @SINCE_1_0.0
*/
- void ThisIsSaferThanReturningVoidStar() const {}
+ void ThisIsSaferThanReturningVoidStar() const
+ {
+ }
/**
* @brief Internal swap function.
* @SINCE_1_0.0
*/
- void Swap( IntrusivePtr& rhs )
+ void Swap(IntrusivePtr& rhs)
{
- T* tmp = mPtr;
- mPtr = rhs.mPtr;
+ T* tmp = mPtr;
+ mPtr = rhs.mPtr;
rhs.mPtr = tmp;
}
- T* mPtr; ///< pointer to RefObject
+ T* mPtr; ///< pointer to RefObject
};
/**
* @return True if the pointers point at the same object
*/
template<typename T, typename U>
-inline bool operator==( IntrusivePtr<T>const& lhs, IntrusivePtr<U>const& rhs )
+inline bool operator==(IntrusivePtr<T> const& lhs, IntrusivePtr<U> const& rhs)
{
return lhs.Get() == rhs.Get();
}
* @return True if the pointers point at different objects
*/
template<typename T, typename U>
-inline bool operator!=( IntrusivePtr<T>const& lhs, IntrusivePtr<U>const &rhs)
+inline bool operator!=(IntrusivePtr<T> const& lhs, IntrusivePtr<U> const& rhs)
{
return lhs.Get() != rhs.Get();
}
* @return True if the intrusive pointer points at the specified object
*/
template<typename T, typename U>
-inline bool operator==( IntrusivePtr<T>const& lhs, U* rhs )
+inline bool operator==(IntrusivePtr<T> const& lhs, U* rhs)
{
return lhs.Get() == rhs;
}
* @return True if the intrusive pointer doesn't point at the specified object
*/
template<typename T, typename U>
-inline bool operator!=( IntrusivePtr<T>const& lhs, U* rhs )
+inline bool operator!=(IntrusivePtr<T> const& lhs, U* rhs)
{
return lhs.Get() != rhs;
}
* @return True if the intrusive pointer points at the specified object
*/
template<typename T, typename U>
-inline bool operator==( T* lhs, IntrusivePtr<U>const& rhs )
+inline bool operator==(T* lhs, IntrusivePtr<U> const& rhs)
{
return lhs == rhs.Get();
}
* @return True if the intrusive pointer doesn't point at the specified object
*/
template<typename T, typename U>
-inline bool operator!=( T* lhs, IntrusivePtr<U>const& rhs )
+inline bool operator!=(T* lhs, IntrusivePtr<U> const& rhs)
{
return lhs != rhs.Get();
}
#include <list>
#undef _LIBCPP_INLINE_VISIBILITY
-#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
+#define _LIBCPP_INLINE_VISIBILITY __attribute__((__visibility__("hidden"), __always_inline__))
#undef _LIBCPP_EXTERN_TEMPLATE
#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
#include <bits/stl_list.h>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ ("hidden")))
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ ("hidden")))
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__("hidden")))
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__("hidden")))
#include <list>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY`
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY`
#endif // #ifdef __clang__
#define DALI_TYPE_TRAITS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* This allows specializations to not have to repeat all flags.
* @SINCE_1_0.0
*/
-template <typename Type>
+template<typename Type>
struct BasicTypes
{
/**
* and cannot be copied by using memcpy etc.
* @SINCE_1_0.0
*/
- enum { IS_TRIVIAL_TYPE = __has_trivial_destructor(Type) && __has_trivial_copy(Type) };
+ enum
+ {
+ IS_TRIVIAL_TYPE = __has_trivial_destructor(Type) && __has_trivial_copy(Type)
+ };
};
/**
*
* @SINCE_1_0.0
*/
-template <typename Type>
-struct TypeTraits : public BasicTypes< Type >
+template<typename Type>
+struct TypeTraits : public BasicTypes<Type>
{
};
#define DALI_VECTOR_WRAPPER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <vector>
#undef _LIBCPP_INLINE_VISIBILITY
-#define _LIBCPP_INLINE_VISIBILITY __attribute__ ((__visibility__("hidden"), __always_inline__))
+#define _LIBCPP_INLINE_VISIBILITY __attribute__((__visibility__("hidden"), __always_inline__))
#undef _LIBCPP_EXTERN_TEMPLATE
#define _LIBCPP_EXTERN_TEMPLATE(...) extern template __VA_ARGS__;
#include <bits/c++config.h>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ ("hidden")))
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ ("hidden")))
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__("hidden")))
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__("hidden")))
#include <vector>
#undef _GLIBCXX_VISIBILITY_ATTR
#undef _GLIBCXX_VISIBILITY
-#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
-#define _GLIBCXX_VISIBILITY(V) __attribute__ ((__visibility__ (#V))) // restore `_GLIBCXX_VISIBILITY`
+#define _GLIBCXX_VISIBILITY_ATTR(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY_ATTR`
+#define _GLIBCXX_VISIBILITY(V) __attribute__((__visibility__(#V))) // restore `_GLIBCXX_VISIBILITY`
#endif // #ifdef __clang__
namespace Dali
{
-
-const uint32_t CORE_MAJOR_VERSION = 1;
-const uint32_t CORE_MINOR_VERSION = 9;
-const uint32_t CORE_MICRO_VERSION = 28;
-const char * const CORE_BUILD_DATE = __DATE__ " " __TIME__;
+const uint32_t CORE_MAJOR_VERSION = 1;
+const uint32_t CORE_MINOR_VERSION = 9;
+const uint32_t CORE_MICRO_VERSION = 30;
+const char* const CORE_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
namespace
#define DALI_CORE_VERSION_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-DALI_CORE_API extern const uint32_t CORE_MAJOR_VERSION; ///< The major version number of the Core library.
-DALI_CORE_API extern const uint32_t CORE_MINOR_VERSION; ///< The minor version number of the Core library.
-DALI_CORE_API extern const uint32_t CORE_MICRO_VERSION; ///< The micro version number of the Core library.
-DALI_CORE_API extern const char * const CORE_BUILD_DATE; ///< The date/time the Core library was built.
+DALI_CORE_API extern const uint32_t CORE_MAJOR_VERSION; ///< The major version number of the Core library.
+DALI_CORE_API extern const uint32_t CORE_MINOR_VERSION; ///< The minor version number of the Core library.
+DALI_CORE_API extern const uint32_t CORE_MICRO_VERSION; ///< The micro version number of the Core library.
+DALI_CORE_API extern const char* const CORE_BUILD_DATE; ///< The date/time the Core library was built.
} // namespace Dali
#endif // DALI_CORE_VERSION_H
*
*/
-#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/actor-enumerations.h>
+#include <dali/public-api/actors/actor.h>
#include <dali/public-api/actors/camera-actor.h>
#include <dali/public-api/actors/custom-actor-impl.h>
#include <dali/public-api/actors/custom-actor.h>
#include <dali/public-api/events/key-event.h>
#include <dali/public-api/events/long-press-gesture-detector.h>
#include <dali/public-api/events/long-press-gesture.h>
-#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/events/pan-gesture-detector.h>
#include <dali/public-api/events/pan-gesture.h>
#include <dali/public-api/events/pinch-gesture-detector.h>
#include <dali/public-api/events/tap-gesture-detector.h>
#include <dali/public-api/events/tap-gesture.h>
#include <dali/public-api/events/touch-event.h>
+#include <dali/public-api/events/wheel-event.h>
#include <dali/public-api/images/native-image-interface.h>
-#include <dali/public-api/images/pixel.h>
#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/images/pixel.h>
#include <dali/public-api/math/angle-axis.h>
#include <dali/public-api/math/compile-time-math.h>
#include <dali/public-api/object/property.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/object/type-info.h>
-#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/type-registry-helper.h>
+#include <dali/public-api/object/type-registry.h>
#include <dali/public-api/object/weak-handle.h>
#include <dali/public-api/render-tasks/render-task-list.h>
#include <dali/public-api/rendering/renderer.h>
#include <dali/public-api/rendering/sampler.h>
#include <dali/public-api/rendering/shader.h>
-#include <dali/public-api/rendering/texture.h>
#include <dali/public-api/rendering/texture-set.h>
+#include <dali/public-api/rendering/texture.h>
#include <dali/public-api/rendering/vertex-buffer.h>
#include <dali/public-api/signals/base-signal.h>
#define DALI_DEVICE_H
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace Device
{
-
/**
* @brief Categorization type about input Device
* @SINCE_1_2.60
*/
namespace Class
{
-
/**
* @brief An enum of Device Class types.
* @SINCE_1_2.60
*/
enum Type
{
- NONE, ///< Not a device. @SINCE_1_2.60
- USER, ///< The user/seat (the user themselves). @SINCE_1_2.60
- KEYBOARD, ///< A regular keyboard, numberpad or attached buttons. @SINCE_1_2.60
- MOUSE, ///< A mouse, trackball or touchpad relative motion device. @SINCE_1_2.60
- TOUCH, ///< A touchscreen with fingers or stylus. @SINCE_1_2.60
- PEN, ///< A special pen device. @SINCE_1_2.60
- POINTER, ///< A pointing device based on laser, infrared or similar technology. @SINCE_1_2.60
- GAMEPAD ///< A gamepad controller or joystick. @SINCE_1_2.60
+ NONE, ///< Not a device. @SINCE_1_2.60
+ USER, ///< The user/seat (the user themselves). @SINCE_1_2.60
+ KEYBOARD, ///< A regular keyboard, numberpad or attached buttons. @SINCE_1_2.60
+ MOUSE, ///< A mouse, trackball or touchpad relative motion device. @SINCE_1_2.60
+ TOUCH, ///< A touchscreen with fingers or stylus. @SINCE_1_2.60
+ PEN, ///< A special pen device. @SINCE_1_2.60
+ POINTER, ///< A pointing device based on laser, infrared or similar technology. @SINCE_1_2.60
+ GAMEPAD ///< A gamepad controller or joystick. @SINCE_1_2.60
};
} // namespace Class
*/
namespace Subclass
{
-
/**
* @brief An enum of Device Subclass types.
* @SINCE_1_2.60
*/
enum Type
{
- NONE, ///< Not a device. @SINCE_1_2.60
- FINGER, ///< The normal flat of your finger. @SINCE_1_2.60
- FINGERNAIL, ///< A fingernail. @SINCE_1_2.60
- KNUCKLE, ///< A Knuckle. @SINCE_1_2.60
- PALM, ///< The palm of a users hand. @SINCE_1_2.60
- HAND_SIDE, ///< The side of your hand. @SINCE_1_2.60
- HAND_FLAT, ///< The flat of your hand. @SINCE_1_2.60
- PEN_TIP, ///< The tip of a pen. @SINCE_1_2.60
- TRACKPAD, ///< A trackpad style mouse. @SINCE_1_2.60
- TRACKPOINT, ///< A trackpoint style mouse. @SINCE_1_2.60
- TRACKBALL, ///< A trackball style mouse. @SINCE_1_2.60
- REMOCON, ///< A remote controller. @SINCE_1_2.61
- VIRTUAL_KEYBOARD, ///< A virtual keyboard. @SINCE_1_2.61
+ NONE, ///< Not a device. @SINCE_1_2.60
+ FINGER, ///< The normal flat of your finger. @SINCE_1_2.60
+ FINGERNAIL, ///< A fingernail. @SINCE_1_2.60
+ KNUCKLE, ///< A Knuckle. @SINCE_1_2.60
+ PALM, ///< The palm of a users hand. @SINCE_1_2.60
+ HAND_SIDE, ///< The side of your hand. @SINCE_1_2.60
+ HAND_FLAT, ///< The flat of your hand. @SINCE_1_2.60
+ PEN_TIP, ///< The tip of a pen. @SINCE_1_2.60
+ TRACKPAD, ///< A trackpad style mouse. @SINCE_1_2.60
+ TRACKPOINT, ///< A trackpoint style mouse. @SINCE_1_2.60
+ TRACKBALL, ///< A trackball style mouse. @SINCE_1_2.60
+ REMOCON, ///< A remote controller. @SINCE_1_2.61
+ VIRTUAL_KEYBOARD, ///< A virtual keyboard. @SINCE_1_2.61
};
} // namespace Subclass
*/
} // namespace Dali
-#endif //DALI_KEY_EVENT_DEVEL_H
+#endif //DALI_KEY_EVENT_DEVEL_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
GestureDetector::GestureDetector(Internal::GestureDetector* internal)
: Handle(internal)
{
{
}
-GestureDetector GestureDetector::DownCast( BaseHandle handle )
+GestureDetector GestureDetector::DownCast(BaseHandle handle)
{
- return GestureDetector( dynamic_cast<Dali::Internal::GestureDetector*>(handle.GetObjectPtr()) );
+ return GestureDetector(dynamic_cast<Dali::Internal::GestureDetector*>(handle.GetObjectPtr()));
}
GestureDetector::~GestureDetector()
#define DALI_GESTURE_DETECTOR_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 DALI_CORE_API GestureDetector : public Handle
{
public: // Creation & Destruction
-
/**
* @brief Creates an uninitialized GestureDetector.
*
* @param[in] handle Handle to an object
* @return Handle to a GestureDetector object or an uninitialized handle
*/
- static GestureDetector DownCast( BaseHandle handle );
+ static GestureDetector DownCast(BaseHandle handle);
/**
* @brief Dali::GestureDetector is intended as a base class.
GestureDetector& operator=(const GestureDetector& rhs);
public: // Actor related
-
/**
* @brief Attaches an actor to the gesture.
*
Actor GetAttachedActor(size_t index) const;
protected:
-
/// @cond internal
/**
* @brief This constructor is used by New() methods of derived classes (For example, PanGestureDetector::New()).
namespace Dali
{
-
/**
* @brief Enumeration for type of gesture.
* @SINCE_1_9.28
namespace Dali
{
-
Gesture::Gesture()
{
}
{
}
-Gesture::Gesture( const Gesture& rhs ) = default;
+Gesture::Gesture(const Gesture& rhs) = default;
-Gesture::Gesture( Gesture&& rhs ) = default;
+Gesture::Gesture(Gesture&& rhs) = default;
-Gesture& Gesture::operator=( const Gesture& rhs ) = default;
+Gesture& Gesture::operator=(const Gesture& rhs) = default;
-Gesture& Gesture::operator=( Gesture&& rhs ) = default;
+Gesture& Gesture::operator=(Gesture&& rhs) = default;
Gesture::~Gesture()
{
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/events/gesture-enumerations.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
class DALI_CORE_API Gesture : public BaseHandle
{
public:
-
/**
* @brief Creates an uninitialized Gesture handle.
*
* @SINCE_1_9.28
* @param[in] rhs A reference to the copied handle
*/
- Gesture( const Gesture& rhs );
+ Gesture(const Gesture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param[in] rhs A reference to the handle to move
*/
- Gesture( Gesture&& rhs );
+ Gesture(Gesture&& rhs);
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- Gesture& operator=( const Gesture& rhs );
+ Gesture& operator=(const Gesture& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the handle to move
* @return A reference to this
*/
- Gesture& operator=( Gesture&& rhs );
+ Gesture& operator=(Gesture&& rhs);
/**
* @brief Non virtual destructor.
uint32_t GetTime() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief Internal constructor.
#include <dali/public-api/events/hover-event.h>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
#include <dali/internal/event/events/hover-event-impl.h>
+#include <dali/public-api/actors/actor.h>
namespace Dali
{
-
HoverEvent::HoverEvent()
: BaseHandle()
{
}
-HoverEvent::HoverEvent( const HoverEvent& rhs ) = default;
+HoverEvent::HoverEvent(const HoverEvent& rhs) = default;
-HoverEvent::HoverEvent( HoverEvent&& rhs ) = default;
+HoverEvent::HoverEvent(HoverEvent&& rhs) = default;
HoverEvent::~HoverEvent()
{
}
-HoverEvent& HoverEvent::operator=( const HoverEvent& rhs ) = default;
+HoverEvent& HoverEvent::operator=(const HoverEvent& rhs) = default;
-HoverEvent& HoverEvent::operator=( HoverEvent&& rhs ) = default;
+HoverEvent& HoverEvent::operator=(HoverEvent&& rhs) = default;
unsigned long HoverEvent::GetTime() const
{
- return GetImplementation( *this ).GetTime();
+ return GetImplementation(*this).GetTime();
}
std::size_t HoverEvent::GetPointCount() const
{
- return GetImplementation( *this ).GetPointCount();
+ return GetImplementation(*this).GetPointCount();
}
-int32_t HoverEvent::GetDeviceId( std::size_t point ) const
+int32_t HoverEvent::GetDeviceId(std::size_t point) const
{
- return GetImplementation( *this ).GetDeviceId( point );
+ return GetImplementation(*this).GetDeviceId(point);
}
-PointState::Type HoverEvent::GetState( std::size_t point ) const
+PointState::Type HoverEvent::GetState(std::size_t point) const
{
- return GetImplementation( *this ).GetState( point );
+ return GetImplementation(*this).GetState(point);
}
-Actor HoverEvent::GetHitActor( std::size_t point ) const
+Actor HoverEvent::GetHitActor(std::size_t point) const
{
- return GetImplementation( *this ).GetHitActor( point );
+ return GetImplementation(*this).GetHitActor(point);
}
-const Vector2& HoverEvent::GetLocalPosition( std::size_t point ) const
+const Vector2& HoverEvent::GetLocalPosition(std::size_t point) const
{
- return GetImplementation( *this ).GetLocalPosition( point );
+ return GetImplementation(*this).GetLocalPosition(point);
}
-const Vector2& HoverEvent::GetScreenPosition( std::size_t point ) const
+const Vector2& HoverEvent::GetScreenPosition(std::size_t point) const
{
- return GetImplementation( *this ).GetScreenPosition( point );
+ return GetImplementation(*this).GetScreenPosition(point);
}
-HoverEvent::HoverEvent( Internal::HoverEvent* internal )
-: BaseHandle( internal )
+HoverEvent::HoverEvent(Internal::HoverEvent* internal)
+: BaseHandle(internal)
{
}
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/events/point-state.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class HoverEvent;
*/
class DALI_CORE_API HoverEvent : public BaseHandle
{
-
public:
-
// Construction & Destruction
/**
* @SINCE_1_9.25
* @param[in] rhs The HoverEvent to copy from
*/
- HoverEvent( const HoverEvent& rhs );
+ HoverEvent(const HoverEvent& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.25
* @param[in] rhs A reference to the moved HoverEvent
*/
- HoverEvent( HoverEvent&& rhs );
+ HoverEvent(HoverEvent&& rhs);
/**
* @brief Destructor.
* @param[in] rhs The HoverEvent to copy from
* @return A reference to this
*/
- HoverEvent& operator=( const HoverEvent& rhs );
+ HoverEvent& operator=(const HoverEvent& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved HoverEvent
* @return A reference to this
*/
- HoverEvent& operator=( HoverEvent&& rhs );
+ HoverEvent& operator=(HoverEvent&& rhs);
// Getters
* @return The Device ID of this point
* @note If point is greater than GetPointCount() then this method will return -1.
*/
- int32_t GetDeviceId( std::size_t point ) const;
+ int32_t GetDeviceId(std::size_t point) const;
/**
* @brief Retrieves the State of the point specified.
* @note If point is greater than GetPointCount() then this method will return PointState::FINISHED.
* @see State
*/
- PointState::Type GetState( std::size_t point ) const;
+ PointState::Type GetState(std::size_t point) const;
/**
* @brief Retrieves the actor that was underneath the point specified.
* @return The actor that was underneath the point specified
* @note If point is greater than GetPointCount() then this method will return an empty handle.
*/
- Actor GetHitActor( std::size_t point ) const;
+ Actor GetHitActor(std::size_t point) const;
/**
* @brief Retrieves the co-ordinates relative to the top-left of the hit-actor at the point specified.
* then you should use Actor::ScreenToLocal().
* @note If point is greater than GetPointCount() then this method will return Vector2::ZERO.
*/
- const Vector2& GetLocalPosition( std::size_t point ) const;
+ const Vector2& GetLocalPosition(std::size_t point) const;
/**
* @brief Retrieves the co-ordinates relative to the top-left of the screen of the point specified.
* @return The co-ordinates relative to the top-left of the screen of the point specified
* @note If point is greater than GetPointCount() then this method will return Vector2::ZERO.
*/
- const Vector2& GetScreenPosition( std::size_t point ) const;
+ const Vector2& GetScreenPosition(std::size_t point) const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized HoverEvent handle.
* @SINCE_1_9.25
* @param[in] hoverEvent A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL HoverEvent( Internal::HoverEvent* hoverEvent );
+ explicit DALI_INTERNAL HoverEvent(Internal::HoverEvent* hoverEvent);
/// @endcond
};
namespace Dali
{
-
KeyEvent::KeyEvent()
: BaseHandle()
{
}
-KeyEvent::KeyEvent( const KeyEvent& rhs ) = default;
+KeyEvent::KeyEvent(const KeyEvent& rhs) = default;
-KeyEvent::KeyEvent( KeyEvent&& rhs ) = default;
+KeyEvent::KeyEvent(KeyEvent&& rhs) = default;
KeyEvent::~KeyEvent()
{
}
-KeyEvent& KeyEvent::operator=( const KeyEvent& rhs ) = default;
+KeyEvent& KeyEvent::operator=(const KeyEvent& rhs) = default;
-KeyEvent& KeyEvent::operator=( KeyEvent&& rhs ) = default;
+KeyEvent& KeyEvent::operator=(KeyEvent&& rhs) = default;
bool KeyEvent::IsShiftModifier() const
{
- return GetImplementation( *this ).IsShiftModifier();
+ return GetImplementation(*this).IsShiftModifier();
}
bool KeyEvent::IsCtrlModifier() const
{
- return GetImplementation( *this ).IsCtrlModifier();
+ return GetImplementation(*this).IsCtrlModifier();
}
bool KeyEvent::IsAltModifier() const
{
- return GetImplementation( *this ).IsAltModifier();
+ return GetImplementation(*this).IsAltModifier();
}
const std::string& KeyEvent::GetCompose() const
{
- return GetImplementation( *this ).GetCompose();
+ return GetImplementation(*this).GetCompose();
}
const std::string& KeyEvent::GetDeviceName() const
{
- return GetImplementation( *this ).GetDeviceName();
+ return GetImplementation(*this).GetDeviceName();
}
Device::Class::Type KeyEvent::GetDeviceClass() const
{
- return GetImplementation( *this ).GetDeviceClass();
+ return GetImplementation(*this).GetDeviceClass();
}
Device::Subclass::Type KeyEvent::GetDeviceSubclass() const
{
- return GetImplementation( *this ).GetDeviceSubclass();
+ return GetImplementation(*this).GetDeviceSubclass();
}
const std::string& KeyEvent::GetKeyName() const
{
- return GetImplementation( *this ).GetKeyName();
+ return GetImplementation(*this).GetKeyName();
}
const std::string& KeyEvent::GetKeyString() const
{
- return GetImplementation( *this ).GetKeyString();
+ return GetImplementation(*this).GetKeyString();
}
const std::string& KeyEvent::GetLogicalKey() const
{
- return GetImplementation( *this ).GetLogicalKey();
+ return GetImplementation(*this).GetLogicalKey();
}
int32_t KeyEvent::GetKeyCode() const
{
- return GetImplementation( *this ).GetKeyCode();
+ return GetImplementation(*this).GetKeyCode();
}
int32_t KeyEvent::GetKeyModifier() const
{
- return GetImplementation( *this ).GetKeyModifier();
+ return GetImplementation(*this).GetKeyModifier();
}
unsigned long KeyEvent::GetTime() const
{
- return GetImplementation( *this ).GetTime();
+ return GetImplementation(*this).GetTime();
}
KeyEvent::State KeyEvent::GetState() const
{
- return GetImplementation( *this ).GetState();
+ return GetImplementation(*this).GetState();
}
-KeyEvent::KeyEvent( Internal::KeyEvent* internal )
-: BaseHandle( internal )
+KeyEvent::KeyEvent(Internal::KeyEvent* internal)
+: BaseHandle(internal)
{
}
*/
// EXTERNAL INCLUDES
-#include <string>
#include <cstdint> // int32_t
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/events/device.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class KeyEvent;
*/
class DALI_CORE_API KeyEvent : public BaseHandle
{
-
public:
-
// Enumerations
/**
*/
enum State
{
- DOWN, ///< Key down @SINCE_1_9.27
- UP, ///< Key up @SINCE_1_9.27
+ DOWN, ///< Key down @SINCE_1_9.27
+ UP, ///< Key up @SINCE_1_9.27
};
/**
* @SINCE_1_2.36
* @param[in] rhs A reference to the copied handle
*/
- KeyEvent( const KeyEvent& rhs );
+ KeyEvent(const KeyEvent& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.27
* @param[in] rhs A reference to the moved handle
*/
- KeyEvent( KeyEvent&& rhs );
+ KeyEvent(KeyEvent&& rhs);
/**
* @brief Copy assignment operator.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- KeyEvent& operator=( const KeyEvent& rhs );
+ KeyEvent& operator=(const KeyEvent& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- KeyEvent& operator=( KeyEvent&& rhs );
+ KeyEvent& operator=(KeyEvent&& rhs);
/**
* @brief Destructor.
State GetState() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized KeyEvent handle.
* @SINCE_1_9.27
* @param[in] keyEvent A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL KeyEvent( Internal::KeyEvent* keyEvent );
+ explicit DALI_INTERNAL KeyEvent(Internal::KeyEvent* keyEvent);
/// @endcond
};
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
LongPressGestureDetector::LongPressGestureDetector(Internal::LongPressGestureDetector* internal)
: GestureDetector(internal)
{
return LongPressGestureDetector(internal.Get());
}
-LongPressGestureDetector LongPressGestureDetector::DownCast( BaseHandle handle )
+LongPressGestureDetector LongPressGestureDetector::DownCast(BaseHandle handle)
{
- return LongPressGestureDetector( dynamic_cast<Dali::Internal::LongPressGestureDetector*>(handle.GetObjectPtr()) );
+ return LongPressGestureDetector(dynamic_cast<Dali::Internal::LongPressGestureDetector*>(handle.GetObjectPtr()));
}
LongPressGestureDetector::~LongPressGestureDetector()
*/
class DALI_CORE_API LongPressGestureDetector : public GestureDetector
{
-public: // Typedefs
-
- typedef Signal< void ( Actor, const LongPressGesture& ) > DetectedSignalType; ///< Gesture detected signal type @SINCE_1_0.0
+public: // Typedefs
+ using DetectedSignalType = Signal<void(Actor, const LongPressGesture&)>; ///< Gesture detected signal type @SINCE_1_0.0
public: // Creation & Destruction
-
/**
* @brief Creates an uninitialized LongPressGestureDetector; this can be initialized with LongPressGestureDetector::New().
*
* @param[in] handle Handle to an object
* @return Handle to a LongPressGestureDetector object or an uninitialized handle
*/
- static LongPressGestureDetector DownCast( BaseHandle handle );
+ static LongPressGestureDetector DownCast(BaseHandle handle);
/**
* @brief Destructor.
LongPressGestureDetector& operator=(const LongPressGestureDetector& rhs);
public: // Setters
-
/**
* @brief Sets the number of touches required.
*
void SetTouchesRequired(uint32_t minTouches, uint32_t maxTouches);
public: // Getters
-
/**
* @brief Retrieves the minimum number of touches required.
*
uint32_t GetMaximumTouchesRequired() const;
public: // Signals
-
/**
* @brief This signal is emitted when the specified long press is detected on the attached actor.
*
DetectedSignalType& DetectedSignal();
public: // Not intended for Application developers
-
/// @cond internal
/**
* @brief This constructor is used by LongPressGestureDetector::New() methods.
*/
explicit DALI_INTERNAL LongPressGestureDetector(Internal::LongPressGestureDetector* internal);
/// @endcond
-
};
/**
namespace Dali
{
-
-LongPressGesture::LongPressGesture( Internal::LongPressGesture* internal )
-: Gesture( internal )
+LongPressGesture::LongPressGesture(Internal::LongPressGesture* internal)
+: Gesture(internal)
{
}
LongPressGesture::LongPressGesture() = default;
-LongPressGesture::LongPressGesture( const LongPressGesture& rhs ) = default;
+LongPressGesture::LongPressGesture(const LongPressGesture& rhs) = default;
-LongPressGesture::LongPressGesture( LongPressGesture&& rhs ) = default;
+LongPressGesture::LongPressGesture(LongPressGesture&& rhs) = default;
-LongPressGesture& LongPressGesture::operator=( const LongPressGesture& rhs ) = default;
+LongPressGesture& LongPressGesture::operator=(const LongPressGesture& rhs) = default;
-LongPressGesture& LongPressGesture::operator=( LongPressGesture&& rhs ) = default;
+LongPressGesture& LongPressGesture::operator=(LongPressGesture&& rhs) = default;
LongPressGesture::~LongPressGesture() = default;
uint32_t LongPressGesture::GetNumberOfTouches() const
{
- return GetImplementation( *this ).GetNumberOfTouches();
+ return GetImplementation(*this).GetNumberOfTouches();
}
const Vector2& LongPressGesture::GetScreenPoint() const
{
- return GetImplementation( *this ).GetScreenPoint();
+ return GetImplementation(*this).GetScreenPoint();
}
const Vector2& LongPressGesture::GetLocalPoint() const
{
- return GetImplementation( *this ).GetLocalPoint();
+ return GetImplementation(*this).GetLocalPoint();
}
} // namespace Dali
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class LongPressGesture;
class DALI_CORE_API LongPressGesture : public Gesture
{
public:
-
/**
* @brief Creates an uninitialized LongPressGesture handle.
*
* @SINCE_1_9.28
* @param[in] rhs A reference to the copied handle
*/
- LongPressGesture( const LongPressGesture& rhs );
+ LongPressGesture(const LongPressGesture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param[in] rhs A reference to the handle to move
*/
- LongPressGesture( LongPressGesture&& rhs );
+ LongPressGesture(LongPressGesture&& rhs);
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- LongPressGesture& operator=( const LongPressGesture& rhs );
+ LongPressGesture& operator=(const LongPressGesture& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- LongPressGesture& operator=( LongPressGesture&& rhs );
+ LongPressGesture& operator=(LongPressGesture&& rhs);
/**
* @brief Non virtual destructor.
const Vector2& GetLocalPoint() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized LongPressGesture handle.
* @param[in] longPressGesture A pointer to a newly allocated Dali resource
* @SINCE_1_9.28
*/
- explicit DALI_INTERNAL LongPressGesture( Internal::LongPressGesture* longPressGesture );
+ explicit DALI_INTERNAL LongPressGesture(Internal::LongPressGesture* longPressGesture);
/// @endcond
-
};
/**
#define DALI_MOUSE_BUTTON_H
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace MouseButton
{
-
/**
* @brief Enumeration for mouse button type.
* @SINCE_1_3_31
*/
enum Type
{
- INVALID = -1, /**< No mouse button event or invalid data */
- PRIMARY = 1, /**< Primary(Left) mouse button */
- SECONDARY = 3, /**< Secondary(Right) mouse button */
- TERTIARY = 2, /**< Center(Wheel) mouse button */
+ INVALID = -1, /**< No mouse button event or invalid data */
+ PRIMARY = 1, /**< Primary(Left) mouse button */
+ SECONDARY = 3, /**< Secondary(Right) mouse button */
+ TERTIARY = 2, /**< Center(Wheel) mouse button */
};
-}
+} // namespace MouseButton
/**
* @}
namespace Dali
{
-
-const Radian PanGestureDetector::DIRECTION_LEFT( -Math::PI );
-const Radian PanGestureDetector::DIRECTION_RIGHT( 0.0f );
-const Radian PanGestureDetector::DIRECTION_UP( -0.5f * Math::PI );
-const Radian PanGestureDetector::DIRECTION_DOWN( 0.5f * Math::PI );
-const Radian PanGestureDetector::DIRECTION_HORIZONTAL( Math::PI );
-const Radian PanGestureDetector::DIRECTION_VERTICAL( -0.5f * Math::PI );
-const Radian PanGestureDetector::DEFAULT_THRESHOLD( 0.25f * Math::PI );
+const Radian PanGestureDetector::DIRECTION_LEFT(-Math::PI);
+const Radian PanGestureDetector::DIRECTION_RIGHT(0.0f);
+const Radian PanGestureDetector::DIRECTION_UP(-0.5f * Math::PI);
+const Radian PanGestureDetector::DIRECTION_DOWN(0.5f * Math::PI);
+const Radian PanGestureDetector::DIRECTION_HORIZONTAL(Math::PI);
+const Radian PanGestureDetector::DIRECTION_VERTICAL(-0.5f * Math::PI);
+const Radian PanGestureDetector::DEFAULT_THRESHOLD(0.25f * Math::PI);
PanGestureDetector::PanGestureDetector(Internal::PanGestureDetector* internal)
: GestureDetector(internal)
return PanGestureDetector(internal.Get());
}
-PanGestureDetector PanGestureDetector::DownCast( BaseHandle handle )
+PanGestureDetector PanGestureDetector::DownCast(BaseHandle handle)
{
- return PanGestureDetector( dynamic_cast<Dali::Internal::PanGestureDetector*>(handle.GetObjectPtr()) );
+ return PanGestureDetector(dynamic_cast<Dali::Internal::PanGestureDetector*>(handle.GetObjectPtr()));
}
PanGestureDetector::~PanGestureDetector()
return GetImplementation(*this).GetMaximumTouchesRequired();
}
-void PanGestureDetector::AddAngle( Radian angle, Radian threshold )
+void PanGestureDetector::AddAngle(Radian angle, Radian threshold)
{
- GetImplementation(*this).AddAngle( angle, threshold );
+ GetImplementation(*this).AddAngle(angle, threshold);
}
-void PanGestureDetector::AddDirection( Radian direction, Radian threshold )
+void PanGestureDetector::AddDirection(Radian direction, Radian threshold)
{
- GetImplementation(*this).AddDirection( direction, threshold );
+ GetImplementation(*this).AddDirection(direction, threshold);
}
size_t PanGestureDetector::GetAngleCount() const
PanGestureDetector::AngleThresholdPair PanGestureDetector::GetAngle(size_t index) const
{
- return GetImplementation(*this).GetAngle( static_cast<uint32_t>( index ) );
+ return GetImplementation(*this).GetAngle(static_cast<uint32_t>(index));
}
void PanGestureDetector::ClearAngles()
GetImplementation(*this).ClearAngles();
}
-void PanGestureDetector::RemoveAngle( Radian angle )
+void PanGestureDetector::RemoveAngle(Radian angle)
{
- GetImplementation(*this).RemoveAngle( angle );
+ GetImplementation(*this).RemoveAngle(angle);
}
-void PanGestureDetector::RemoveDirection( Radian direction )
+void PanGestureDetector::RemoveDirection(Radian direction)
{
- GetImplementation(*this).RemoveDirection( direction );
+ GetImplementation(*this).RemoveDirection(direction);
}
PanGestureDetector::DetectedSignalType& PanGestureDetector::DetectedSignal()
return GetImplementation(*this).DetectedSignal();
}
-void PanGestureDetector::SetPanGestureProperties( const Dali::PanGesture& pan )
+void PanGestureDetector::SetPanGestureProperties(const Dali::PanGesture& pan)
{
- Internal::PanGestureDetector::SetPanGestureProperties( pan );
+ Internal::PanGestureDetector::SetPanGestureProperties(pan);
}
} // namespace Dali
namespace Dali
{
-
struct Radian;
namespace Internal DALI_INTERNAL
class DALI_CORE_API PanGestureDetector : public GestureDetector
{
public:
-
/**
* @brief Enumeration for the instance of properties belonging to the PanGestureDetector class.
* @SINCE_1_0.0
};
// Typedefs
- typedef Signal< void ( Actor, const PanGesture& ) > DetectedSignalType; ///< Pan gesture detected signal type @SINCE_1_0.0
+ using DetectedSignalType = Signal<void(Actor, const PanGesture&)>; ///< Pan gesture detected signal type @SINCE_1_0.0
// Directional Pan
- typedef std::pair< Radian, Radian > AngleThresholdPair; ///< Range of angles for a direction @SINCE_1_0.0
+ using AngleThresholdPair = std::pair<Radian, Radian>; ///< Range of angles for a direction @SINCE_1_0.0
static const Radian DIRECTION_LEFT; ///< For a left pan (-PI Radians).
static const Radian DIRECTION_RIGHT; ///< For a right pan (0 Radians).
static const Radian DIRECTION_HORIZONTAL; ///< For a left and right pan (PI Radians). Useful for AddDirection().
static const Radian DIRECTION_VERTICAL; ///< For an up and down pan (-0.5 * PI Radians). Useful for AddDirection().
- static const Radian DEFAULT_THRESHOLD; ///< The default threshold is PI * 0.25 radians (or 45 degrees).
+ static const Radian DEFAULT_THRESHOLD; ///< The default threshold is PI * 0.25 radians (or 45 degrees).
public: // Creation & Destruction
-
/**
* @brief Creates an uninitialized PanGestureDetector; this can be initialized with PanGestureDetector::New().
*
* @param[in] handle Handle to an object
* @return Handle to a PanGestureDetector object or an uninitialized handle
*/
- static PanGestureDetector DownCast( BaseHandle handle );
+ static PanGestureDetector DownCast(BaseHandle handle);
/**
* @brief Destructor.
PanGestureDetector& operator=(const PanGestureDetector& rhs);
public: // Setters
-
/**
* @brief This is the minimum number of touches required for the pan gesture to be detected.
*
void SetMaximumTouchesRequired(uint32_t maximum);
public: // Getters
-
/**
* @brief Retrieves the minimum number of touches required for the pan gesture to be detected.
*
uint32_t GetMaximumTouchesRequired() const;
public: // Directional Panning
-
/**
* @brief The pan gesture is only emitted if the pan occurs in the direction specified by this method with a +/- threshold allowance.
*
* @note If the threshold is greater than PI, then PI will be used as the threshold.
*
*/
- void AddAngle( Radian angle, Radian threshold = DEFAULT_THRESHOLD );
+ void AddAngle(Radian angle, Radian threshold = DEFAULT_THRESHOLD);
/**
* @brief A helper method for adding bi-directional angles where the pan should take place.
*
* @see AddAngle
*/
- void AddDirection( Radian direction, Radian threshold = DEFAULT_THRESHOLD );
+ void AddDirection(Radian direction, Radian threshold = DEFAULT_THRESHOLD);
/**
* @brief Returns the count of angles that this pan gesture detector emits a signal.
* @note If an angle outside the range in AddAngle() is given, then the value is wrapped within
* the range and that is removed.
*/
- void RemoveAngle( Radian angle );
+ void RemoveAngle(Radian angle);
/**
* @brief Removes the two angles that make up the direction from the container.
* @note If a direction outside the range in AddAngle() is given, then the value is wrapped within
* the range and that is removed.
*/
- void RemoveDirection( Radian direction );
+ void RemoveDirection(Radian direction);
public: // Signals
-
/**
* @brief This signal is emitted when the pan gesture is detected on the attached actor.
*
DetectedSignalType& DetectedSignal();
public: // Pan Properties Setters
-
/**
* @brief Allows setting of the pan properties that are returned in constraints.
*
* @param[in] pan The pan gesture to set
* @note If a normal pan is taking place, then any value set is ignored.
*/
- static void SetPanGestureProperties( const PanGesture& pan );
+ static void SetPanGestureProperties(const PanGesture& pan);
public: // Not intended for Application developers
-
/// @cond internal
/**
* @brief This constructor is used by PanGestureDetector::New() methods.
*/
explicit DALI_INTERNAL PanGestureDetector(Internal::PanGestureDetector* internal);
/// @endcond
-
};
/**
#include <dali/public-api/events/pan-gesture.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/internal/event/events/pan-gesture/pan-gesture-impl.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
-PanGesture::PanGesture( Internal::PanGesture* internal )
-: Gesture( internal )
+PanGesture::PanGesture(Internal::PanGesture* internal)
+: Gesture(internal)
{
}
PanGesture::PanGesture() = default;
-PanGesture::PanGesture( const PanGesture& rhs ) = default;
+PanGesture::PanGesture(const PanGesture& rhs) = default;
-PanGesture::PanGesture( PanGesture&& rhs ) = default;
+PanGesture::PanGesture(PanGesture&& rhs) = default;
-PanGesture& PanGesture::operator=( const PanGesture& rhs ) = default;
+PanGesture& PanGesture::operator=(const PanGesture& rhs) = default;
-PanGesture& PanGesture::operator=( PanGesture&& rhs ) = default;
+PanGesture& PanGesture::operator=(PanGesture&& rhs) = default;
PanGesture::~PanGesture() = default;
const Vector2& PanGesture::GetVelocity() const
{
- return GetImplementation( *this ).GetVelocity();
+ return GetImplementation(*this).GetVelocity();
}
const Vector2& PanGesture::GetDisplacement() const
{
- return GetImplementation( *this ).GetDisplacement();
+ return GetImplementation(*this).GetDisplacement();
}
const Vector2& PanGesture::GetPosition() const
{
- return GetImplementation( *this ).GetPosition();
+ return GetImplementation(*this).GetPosition();
}
const Vector2& PanGesture::GetScreenVelocity() const
{
- return GetImplementation( *this ).GetScreenVelocity();
+ return GetImplementation(*this).GetScreenVelocity();
}
const Vector2& PanGesture::GetScreenDisplacement() const
{
- return GetImplementation( *this ).GetScreenDisplacement();
+ return GetImplementation(*this).GetScreenDisplacement();
}
const Vector2& PanGesture::GetScreenPosition() const
{
- return GetImplementation( *this ).GetScreenPosition();
+ return GetImplementation(*this).GetScreenPosition();
}
uint32_t PanGesture::GetNumberOfTouches() const
{
- return GetImplementation( *this ).GetNumberOfTouches();
+ return GetImplementation(*this).GetNumberOfTouches();
}
float PanGesture::GetSpeed() const
{
- return GetImplementation( *this ).GetSpeed();
+ return GetImplementation(*this).GetSpeed();
}
float PanGesture::GetDistance() const
{
- return GetImplementation( *this ).GetDistance();
+ return GetImplementation(*this).GetDistance();
}
float PanGesture::GetScreenSpeed() const
{
- return GetImplementation( *this ).GetScreenSpeed();
+ return GetImplementation(*this).GetScreenSpeed();
}
float PanGesture::GetScreenDistance() const
{
- return GetImplementation( *this ).GetScreenDistance();
+ return GetImplementation(*this).GetScreenDistance();
}
} // namespace Dali
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class PanGesture;
* A pan gesture will continue to be sent to the actor under than initial pan until it ends.
* @SINCE_1_9.28
*/
-class DALI_CORE_API PanGesture: public Gesture
+class DALI_CORE_API PanGesture : public Gesture
{
public:
-
/**
* @brief Creates an uninitialized PanGesture handle.
*
* @SINCE_1_9.28
* @param[in] rhs A reference to the copied handle
*/
- PanGesture( const PanGesture& rhs );
+ PanGesture(const PanGesture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param[in] rhs A reference to the moved handle
*/
- PanGesture( PanGesture&& rhs );
+ PanGesture(PanGesture&& rhs);
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- PanGesture& operator=( const PanGesture& rhs );
+ PanGesture& operator=(const PanGesture& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PanGesture& operator=( PanGesture&& rhs );
+ PanGesture& operator=(PanGesture&& rhs);
/**
* @brief Non virtual destructor.
float GetScreenDistance() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized PanGesture handle.
* @param[in] panGesture A pointer to a newly allocated Dali resource
* @SINCE_1_9.28
*/
- explicit DALI_INTERNAL PanGesture( Internal::PanGesture* panGesture );
+ explicit DALI_INTERNAL PanGesture(Internal::PanGesture* panGesture);
/// @endcond
-
};
/**
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
return PinchGestureDetector(internal.Get());
}
-PinchGestureDetector PinchGestureDetector::DownCast( BaseHandle handle )
+PinchGestureDetector PinchGestureDetector::DownCast(BaseHandle handle)
{
- return PinchGestureDetector( dynamic_cast<Dali::Internal::PinchGestureDetector*>(handle.GetObjectPtr()) );
+ return PinchGestureDetector(dynamic_cast<Dali::Internal::PinchGestureDetector*>(handle.GetObjectPtr()));
}
PinchGestureDetector::~PinchGestureDetector()
class DALI_CORE_API PinchGestureDetector : public GestureDetector
{
public: // Typedefs
-
/**
* @brief Signal type.
* @SINCE_1_0.0
*/
- typedef Signal< void ( Actor, const PinchGesture& ) > DetectedSignalType;
+ using DetectedSignalType = Signal<void(Actor, const PinchGesture&)>;
public: // Creation & Destruction
-
/**
* @brief Creates an uninitialized PinchGestureDetector; this can be initialized with PinchGestureDetector::New().
*
* @param[in] handle Handle to an object
* @return Handle to a PinchGestureDetector object or an uninitialized handle
*/
- static PinchGestureDetector DownCast( BaseHandle handle );
+ static PinchGestureDetector DownCast(BaseHandle handle);
/**
* @brief Destructor.
PinchGestureDetector& operator=(const PinchGestureDetector& rhs);
public: // Signals
-
/**
* @brief This signal is emitted when the pinch gesture is detected on the attached actor.
*
DetectedSignalType& DetectedSignal();
public: // Not intended for Application developers
-
/// @cond internal
/**
* @brief This constructor is used by PinchGestureDetector::New() methods.
*/
explicit DALI_INTERNAL PinchGestureDetector(Internal::PinchGestureDetector* internal);
/// @endcond
-
};
/**
#include <dali/public-api/events/pinch-gesture.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/internal/event/events/pinch-gesture/pinch-gesture-impl.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
-PinchGesture::PinchGesture( Internal::PinchGesture* internal )
-: Gesture( internal )
+PinchGesture::PinchGesture(Internal::PinchGesture* internal)
+: Gesture(internal)
{
}
PinchGesture::PinchGesture() = default;
-PinchGesture::PinchGesture( const PinchGesture& rhs ) = default;
+PinchGesture::PinchGesture(const PinchGesture& rhs) = default;
-PinchGesture::PinchGesture( PinchGesture&& rhs ) = default;
+PinchGesture::PinchGesture(PinchGesture&& rhs) = default;
-PinchGesture& PinchGesture::operator=( const PinchGesture& rhs ) = default;
+PinchGesture& PinchGesture::operator=(const PinchGesture& rhs) = default;
-PinchGesture& PinchGesture::operator=( PinchGesture&& rhs ) = default;
+PinchGesture& PinchGesture::operator=(PinchGesture&& rhs) = default;
PinchGesture::~PinchGesture() = default;
float PinchGesture::GetScale() const
{
- return GetImplementation( *this ).GetScale();
+ return GetImplementation(*this).GetScale();
}
float PinchGesture::GetSpeed() const
{
- return GetImplementation( *this ).GetSpeed();
+ return GetImplementation(*this).GetSpeed();
}
const Vector2& PinchGesture::GetScreenCenterPoint() const
{
- return GetImplementation( *this ).GetScreenCenterPoint();
+ return GetImplementation(*this).GetScreenCenterPoint();
}
const Vector2& PinchGesture::GetLocalCenterPoint() const
{
- return GetImplementation( *this ).GetLocalCenterPoint();
+ return GetImplementation(*this).GetLocalCenterPoint();
}
} // namespace Dali
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class PinchGesture;
* until the pinch ends.
* @SINCE_1_9.28
*/
-class DALI_CORE_API PinchGesture: public Gesture
+class DALI_CORE_API PinchGesture : public Gesture
{
public:
-
/**
* @brief Creates an uninitialized PinchGesture handle.
*
* @SINCE_1_9.28
* @param[in] rhs A reference to the copied handle
*/
- PinchGesture( const PinchGesture& rhs );
+ PinchGesture(const PinchGesture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param[in] rhs A reference to the moved handle
*/
- PinchGesture( PinchGesture&& rhs );
+ PinchGesture(PinchGesture&& rhs);
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- PinchGesture& operator=( const PinchGesture& rhs );
+ PinchGesture& operator=(const PinchGesture& rhs);
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- PinchGesture& operator=( PinchGesture&& rhs );
+ PinchGesture& operator=(PinchGesture&& rhs);
/**
* @brief Non virtual destructor.
const Vector2& GetLocalCenterPoint() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized PinchGesture handle.
* @param[in] PinchGesture A pointer to a newly allocated Dali resource
* @SINCE_1_9.28
*/
- explicit DALI_INTERNAL PinchGesture( Internal::PinchGesture* pinchGesture );
+ explicit DALI_INTERNAL PinchGesture(Internal::PinchGesture* pinchGesture);
/// @endcond
-
};
/**
#define DALI_POINT_STATE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace PointState
{
-
/**
* @brief Enumeration for point state type.
* @SINCE_1_1.37
*/
enum Type
{
- STARTED, /**< Touch or hover started */
- FINISHED, /**< Touch or hover finished */
- DOWN = STARTED, /**< Screen touched */
- UP = FINISHED, /**< Touch stopped */
- MOTION, /**< Finger dragged or hovered */
- LEAVE, /**< Leave the boundary of an actor */
- STATIONARY, /**< No change from last event. Useful when a multi-point event occurs where
+ STARTED, /**< Touch or hover started */
+ FINISHED, /**< Touch or hover finished */
+ DOWN = STARTED, /**< Screen touched */
+ UP = FINISHED, /**< Touch stopped */
+ MOTION, /**< Finger dragged or hovered */
+ LEAVE, /**< Leave the boundary of an actor */
+ STATIONARY, /**< No change from last event. Useful when a multi-point event occurs where
all points are sent but indicates that this particular point has not changed
since the last time */
- INTERRUPTED, /**< A system event has occurred which has interrupted the touch or hover event sequence. */
+ INTERRUPTED, /**< A system event has occurred which has interrupted the touch or hover event sequence. */
};
-}
+} // namespace PointState
/**
* @}
namespace Dali
{
-
-RotationGestureDetector::RotationGestureDetector( Internal::RotationGestureDetector* internal )
-: GestureDetector( internal )
+RotationGestureDetector::RotationGestureDetector(Internal::RotationGestureDetector* internal)
+: GestureDetector(internal)
{
}
{
Internal::RotationGestureDetectorPtr internal = Internal::RotationGestureDetector::New();
- return RotationGestureDetector( internal.Get() );
+ return RotationGestureDetector(internal.Get());
}
-RotationGestureDetector RotationGestureDetector::DownCast( BaseHandle handle )
+RotationGestureDetector RotationGestureDetector::DownCast(BaseHandle handle)
{
- return RotationGestureDetector( dynamic_cast<Dali::Internal::RotationGestureDetector*>( handle.GetObjectPtr() ) );
+ return RotationGestureDetector(dynamic_cast<Dali::Internal::RotationGestureDetector*>(handle.GetObjectPtr()));
}
RotationGestureDetector::~RotationGestureDetector()
{
}
-RotationGestureDetector::RotationGestureDetector( const RotationGestureDetector& handle )
-: GestureDetector( handle )
+RotationGestureDetector::RotationGestureDetector(const RotationGestureDetector& handle)
+: GestureDetector(handle)
{
}
-RotationGestureDetector& RotationGestureDetector::operator=( const RotationGestureDetector& rhs )
+RotationGestureDetector& RotationGestureDetector::operator=(const RotationGestureDetector& rhs)
{
- BaseHandle::operator=( rhs );
+ BaseHandle::operator=(rhs);
return *this;
}
RotationGestureDetector::DetectedSignalType& RotationGestureDetector::DetectedSignal()
{
- return GetImplementation( *this ).DetectedSignal();
+ return GetImplementation(*this).DetectedSignal();
}
} // namespace Dali
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class RotationGestureDetector;
class DALI_CORE_API RotationGestureDetector : public GestureDetector
{
public: // Typedefs
-
/**
* @brief Signal type.
*/
- typedef Signal< void ( Actor, const RotationGesture& ) > DetectedSignalType;
+ using DetectedSignalType = Signal<void(Actor, const RotationGesture&)>;
public: // Creation & Destruction
-
/**
* @brief Creates an uninitialized RotationGestureDetector; this can be initialized with RotationGestureDetector::New().
*
* @param[in] handle Handle to an object
* @return Handle to a RotationGestureDetector object or an uninitialized handle
*/
- static RotationGestureDetector DownCast( BaseHandle handle );
+ static RotationGestureDetector DownCast(BaseHandle handle);
/**
* @brief Destructor.
RotationGestureDetector& operator=(const RotationGestureDetector& rhs);
public: // Signals
-
/**
* @brief This signal is emitted when the rotation gesture is detected on the attached actor.
*
DetectedSignalType& DetectedSignal();
public: // Not intended for Application developers
-
/// @cond internal
/**
* @brief This constructor is used by RotationGestureDetector::New() methods.
*/
explicit DALI_INTERNAL RotationGestureDetector(Internal::RotationGestureDetector* internal);
/// @endcond
-
};
} // namespace Dali
#include <dali/public-api/events/rotation-gesture.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/internal/event/events/rotation-gesture/rotation-gesture-impl.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
-RotationGesture::RotationGesture( Internal::RotationGesture* internal )
-: Gesture( internal )
+RotationGesture::RotationGesture(Internal::RotationGesture* internal)
+: Gesture(internal)
{
}
RotationGesture::RotationGesture() = default;
-RotationGesture::RotationGesture( const RotationGesture& rhs ) = default;
+RotationGesture::RotationGesture(const RotationGesture& rhs) = default;
-RotationGesture::RotationGesture( RotationGesture&& rhs ) = default;
+RotationGesture::RotationGesture(RotationGesture&& rhs) = default;
-RotationGesture& RotationGesture::operator=( const RotationGesture& rhs ) = default;
+RotationGesture& RotationGesture::operator=(const RotationGesture& rhs) = default;
-RotationGesture& RotationGesture::operator=( RotationGesture&& rhs ) = default;
+RotationGesture& RotationGesture::operator=(RotationGesture&& rhs) = default;
RotationGesture::~RotationGesture() = default;
const Radian& RotationGesture::GetRotation() const
{
- return GetImplementation( *this ).GetRotation();
+ return GetImplementation(*this).GetRotation();
}
const Vector2& RotationGesture::GetScreenCenterPoint() const
{
- return GetImplementation( *this ).GetScreenCenterPoint();
+ return GetImplementation(*this).GetScreenCenterPoint();
}
const Vector2& RotationGesture::GetLocalCenterPoint() const
{
- return GetImplementation( *this ).GetLocalCenterPoint();
+ return GetImplementation(*this).GetLocalCenterPoint();
}
} // namespace Dali
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class RotationGesture;
* until the rotation ends.
* @SINCE_1_9.28
*/
-class DALI_CORE_API RotationGesture: public Gesture
+class DALI_CORE_API RotationGesture : public Gesture
{
public:
-
/**
* @brief Creates an uninitialized RotationGesture handle.
*
* @SINCE_1_9.28
* @param[in] rhs A reference to the copied handle
*/
- RotationGesture( const RotationGesture& rhs );
+ RotationGesture(const RotationGesture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param[in] rhs A reference to the moved handle
*/
- RotationGesture( RotationGesture&& rhs );
+ RotationGesture(RotationGesture&& rhs);
/**
* @brief Assignment operator.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- RotationGesture& operator=( const RotationGesture& rhs );
+ RotationGesture& operator=(const RotationGesture& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- RotationGesture& operator=( RotationGesture&& rhs );
+ RotationGesture& operator=(RotationGesture&& rhs);
/**
* @brief Non virtual destructor.
const Vector2& GetLocalCenterPoint() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized RotationGesture handle.
* @param[in] rotationGesture A pointer to a newly allocated Dali resource
* @SINCE_1_9.28
*/
- explicit DALI_INTERNAL RotationGesture( Internal::RotationGesture* rotationGesture );
+ explicit DALI_INTERNAL RotationGesture(Internal::RotationGesture* rotationGesture);
/// @endcond
};
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
return TapGestureDetector(internal.Get());
}
-TapGestureDetector TapGestureDetector::New(uint32_t tapsRequired )
+TapGestureDetector TapGestureDetector::New(uint32_t tapsRequired)
{
- Internal::TapGestureDetectorPtr internal = Internal::TapGestureDetector::New( tapsRequired );
+ Internal::TapGestureDetectorPtr internal = Internal::TapGestureDetector::New(tapsRequired);
return TapGestureDetector(internal.Get());
}
-TapGestureDetector TapGestureDetector::DownCast( BaseHandle handle )
+TapGestureDetector TapGestureDetector::DownCast(BaseHandle handle)
{
- return TapGestureDetector( dynamic_cast<Dali::Internal::TapGestureDetector*>(handle.GetObjectPtr()) );
+ return TapGestureDetector(dynamic_cast<Dali::Internal::TapGestureDetector*>(handle.GetObjectPtr()));
}
TapGestureDetector::~TapGestureDetector()
class DALI_CORE_API TapGestureDetector : public GestureDetector
{
public: // Typedefs
-
/**
* @brief Signal type for detected signal.
* @SINCE_1_0.0
*/
- typedef Signal< void ( Actor, const TapGesture& ) > DetectedSignalType;
+ using DetectedSignalType = Signal<void(Actor, const TapGesture&)>;
public: // Creation & Destruction
-
/**
* @brief Creates an uninitialized TapGestureDetector; this can be initialized with TapGestureDetector::New().
*
* @param[in] tapsRequired The minimum & maximum number of taps required
* @return A handle to a newly allocated Dali resource
*/
- static TapGestureDetector New( uint32_t tapsRequired );
+ static TapGestureDetector New(uint32_t tapsRequired);
/**
* @brief Downcasts a handle to TapGestureDetector handle.
* @param[in] handle Handle to an object
* @return Handle to a TapGestureDetector object or an uninitialized handle
*/
- static TapGestureDetector DownCast( BaseHandle handle );
+ static TapGestureDetector DownCast(BaseHandle handle);
/**
* @brief Destructor.
TapGestureDetector& operator=(const TapGestureDetector& rhs);
public: // Setters
-
/**
* @brief Sets the minimum number of taps required.
*
* @pre The gesture detector has been initialized.
* @note The default is '1', the maximum is 2.
*/
- void SetMinimumTapsRequired( uint32_t minimumTaps );
+ void SetMinimumTapsRequired(uint32_t minimumTaps);
/**
* @brief Sets the maximum number of taps required.
* @pre The gesture detector has been initialized.
* @note The default is '1', the maximum is 2.
*/
- void SetMaximumTapsRequired( uint32_t maximumTaps );
+ void SetMaximumTapsRequired(uint32_t maximumTaps);
public: // Getters
-
/**
* @brief Retrieves the minimum number of taps required.
*
uint32_t GetMaximumTapsRequired() const;
public: // Signals
-
/**
* @brief This signal is emitted when the specified tap is detected on the attached actor.
*
DetectedSignalType& DetectedSignal();
public: // Not intended for Application developers
-
/// @cond internal
/**
* @brief This constructor is used by TapGestureDetector::New() methods.
#include <dali/public-api/events/tap-gesture.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/internal/event/events/tap-gesture/tap-gesture-impl.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
-TapGesture::TapGesture( Internal::TapGesture* internal )
-: Gesture( internal )
+TapGesture::TapGesture(Internal::TapGesture* internal)
+: Gesture(internal)
{
}
TapGesture::TapGesture() = default;
-TapGesture::TapGesture( const TapGesture& rhs ) = default;
+TapGesture::TapGesture(const TapGesture& rhs) = default;
-TapGesture::TapGesture( TapGesture&& rhs ) = default;
+TapGesture::TapGesture(TapGesture&& rhs) = default;
-TapGesture& TapGesture::operator=( const TapGesture& rhs ) = default;
+TapGesture& TapGesture::operator=(const TapGesture& rhs) = default;
-TapGesture& TapGesture::operator=( TapGesture&& rhs ) = default;
+TapGesture& TapGesture::operator=(TapGesture&& rhs) = default;
TapGesture::~TapGesture() = default;
uint32_t TapGesture::GetNumberOfTaps() const
{
- return GetImplementation( *this ).GetNumberOfTaps();
+ return GetImplementation(*this).GetNumberOfTaps();
}
uint32_t TapGesture::GetNumberOfTouches() const
{
- return GetImplementation( *this ).GetNumberOfTouches();
+ return GetImplementation(*this).GetNumberOfTouches();
}
const Vector2& TapGesture::GetScreenPoint() const
{
- return GetImplementation( *this ).GetScreenPoint();
+ return GetImplementation(*this).GetScreenPoint();
}
const Vector2& TapGesture::GetLocalPoint() const
{
- return GetImplementation( *this ).GetLocalPoint();
+ return GetImplementation(*this).GetLocalPoint();
}
} // namespace Dali
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class TapGesture;
class DALI_CORE_API TapGesture : public Gesture
{
public:
-
/**
* @brief Creates an uninitialized TapGesture handle.
*
* @SINCE_1_9.28
* @param rhs A reference to the copied handle
*/
- TapGesture( const TapGesture& rhs );
+ TapGesture(const TapGesture& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param rhs The handle to move.
*/
- TapGesture( TapGesture&& rhs );
+ TapGesture(TapGesture&& rhs);
/**
* @brief Assignment operator.
* @param rhs A reference to the copied handle
* @return A reference to this
*/
- TapGesture& operator=( const TapGesture& rhs );
+ TapGesture& operator=(const TapGesture& rhs);
/**
* @brief Move assignment operator.
* @SINCE_1_9.28
* @param rhs The handle to move.
*/
- TapGesture& operator=( TapGesture&& rhs );
+ TapGesture& operator=(TapGesture&& rhs);
/**
* @brief Non virtual destructor.
const Vector2& GetLocalPoint() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized TapGesture handle.
* @param[in] tapGesture A pointer to a newly allocated Dali resource
* @SINCE_1_9.28
*/
- explicit DALI_INTERNAL TapGesture( Internal::TapGesture* tapGesture );
+ explicit DALI_INTERNAL TapGesture(Internal::TapGesture* tapGesture);
/// @endcond
};
#include <dali/public-api/events/touch-event.h>
// INTERNAL INCLUDES
-#include <dali/public-api/actors/actor.h>
#include <dali/internal/event/events/touch-event-impl.h>
+#include <dali/public-api/actors/actor.h>
#include <cstdio>
namespace Dali
{
-
TouchEvent::TouchEvent() = default;
-TouchEvent::TouchEvent( const TouchEvent& other ) = default;
+TouchEvent::TouchEvent(const TouchEvent& other) = default;
-TouchEvent::TouchEvent( TouchEvent&& other ) = default;
+TouchEvent::TouchEvent(TouchEvent&& other) = default;
TouchEvent::~TouchEvent() = default;
-TouchEvent& TouchEvent::operator=( const TouchEvent& other ) = default;
+TouchEvent& TouchEvent::operator=(const TouchEvent& other) = default;
-TouchEvent& TouchEvent::operator=( TouchEvent&& other ) = default;
+TouchEvent& TouchEvent::operator=(TouchEvent&& other) = default;
unsigned long TouchEvent::GetTime() const
{
- return GetImplementation( *this ).GetTime();
+ return GetImplementation(*this).GetTime();
}
std::size_t TouchEvent::GetPointCount() const
{
- return GetImplementation( *this ).GetPointCount();
+ return GetImplementation(*this).GetPointCount();
}
-int32_t TouchEvent::GetDeviceId( std::size_t point ) const
+int32_t TouchEvent::GetDeviceId(std::size_t point) const
{
- return GetImplementation( *this ).GetDeviceId( point );
+ return GetImplementation(*this).GetDeviceId(point);
}
-PointState::Type TouchEvent::GetState( std::size_t point ) const
+PointState::Type TouchEvent::GetState(std::size_t point) const
{
- return GetImplementation( *this ).GetState( point );
+ return GetImplementation(*this).GetState(point);
}
-Actor TouchEvent::GetHitActor( std::size_t point ) const
+Actor TouchEvent::GetHitActor(std::size_t point) const
{
- return GetImplementation( *this ).GetHitActor( point );
+ return GetImplementation(*this).GetHitActor(point);
}
-const Vector2& TouchEvent::GetLocalPosition( std::size_t point ) const
+const Vector2& TouchEvent::GetLocalPosition(std::size_t point) const
{
- return GetImplementation( *this ).GetLocalPosition( point );
+ return GetImplementation(*this).GetLocalPosition(point);
}
-const Vector2& TouchEvent::GetScreenPosition( std::size_t point ) const
+const Vector2& TouchEvent::GetScreenPosition(std::size_t point) const
{
- return GetImplementation( *this ).GetScreenPosition( point );
+ return GetImplementation(*this).GetScreenPosition(point);
}
-float TouchEvent::GetRadius( std::size_t point ) const
+float TouchEvent::GetRadius(std::size_t point) const
{
- return GetImplementation( *this ).GetRadius( point );
+ return GetImplementation(*this).GetRadius(point);
}
-const Vector2& TouchEvent::GetEllipseRadius( std::size_t point ) const
+const Vector2& TouchEvent::GetEllipseRadius(std::size_t point) const
{
- return GetImplementation( *this ).GetEllipseRadius( point );
+ return GetImplementation(*this).GetEllipseRadius(point);
}
-float TouchEvent::GetPressure( std::size_t point ) const
+float TouchEvent::GetPressure(std::size_t point) const
{
- return GetImplementation( *this ).GetPressure( point );
+ return GetImplementation(*this).GetPressure(point);
}
-Degree TouchEvent::GetAngle( std::size_t point ) const
+Degree TouchEvent::GetAngle(std::size_t point) const
{
- return GetImplementation( *this ).GetAngle( point );
+ return GetImplementation(*this).GetAngle(point);
}
-Device::Class::Type TouchEvent::GetDeviceClass( std::size_t point ) const
+Device::Class::Type TouchEvent::GetDeviceClass(std::size_t point) const
{
- return GetImplementation( *this ).GetDeviceClass( point );
+ return GetImplementation(*this).GetDeviceClass(point);
}
-Device::Subclass::Type TouchEvent::GetDeviceSubclass( std::size_t point ) const
+Device::Subclass::Type TouchEvent::GetDeviceSubclass(std::size_t point) const
{
- return GetImplementation( *this ).GetDeviceSubclass( point );
+ return GetImplementation(*this).GetDeviceSubclass(point);
}
-MouseButton::Type TouchEvent::GetMouseButton( std::size_t point ) const
+MouseButton::Type TouchEvent::GetMouseButton(std::size_t point) const
{
- return GetImplementation( *this ).GetMouseButton( point );
+ return GetImplementation(*this).GetMouseButton(point);
}
-TouchEvent::TouchEvent( Internal::TouchEvent* internal )
-: BaseHandle( internal )
+TouchEvent::TouchEvent(Internal::TouchEvent* internal)
+: BaseHandle(internal)
{
}
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/events/device.h>
+#include <dali/public-api/events/mouse-button.h>
#include <dali/public-api/events/point-state.h>
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/math/degree.h>
-#include <dali/public-api/events/mouse-button.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class TouchEvent;
class DALI_CORE_API TouchEvent : public BaseHandle
{
public:
-
// Construction & Destruction
/**
* @SINCE_1_9.26
* @param[in] other The TouchEvent to copy from
*/
- TouchEvent( const TouchEvent& other );
+ TouchEvent(const TouchEvent& other);
/**
* @brief Move constructor.
* @SINCE_1_9.28
* @param[in] other The TouchEvent to move
*/
- TouchEvent( TouchEvent&& other );
+ TouchEvent(TouchEvent&& other);
/**
* @brief Destructor.
* @param[in] other The TouchEvent to copy from
* @return A reference to this
*/
- TouchEvent& operator=( const TouchEvent& other );
+ TouchEvent& operator=(const TouchEvent& other);
/**
* @brief Move assignment Operator.
* @param[in] other The TouchEvent to move
* @return A reference to this
*/
- TouchEvent& operator=( TouchEvent&& other );
+ TouchEvent& operator=(TouchEvent&& other);
// Getters
* @return The Device ID of this point
* @note If point is greater than GetPointCount() then this method will return -1.
*/
- int32_t GetDeviceId( std::size_t point ) const;
+ int32_t GetDeviceId(std::size_t point) const;
/**
* @brief Retrieves the State of the point specified.
* @note If point is greater than GetPointCount() then this method will return PointState::FINISHED.
* @see State
*/
- PointState::Type GetState( std::size_t point ) const;
+ PointState::Type GetState(std::size_t point) const;
/**
* @brief Retrieves the actor that was underneath the point specified.
* @return The actor that was underneath the point specified
* @note If point is greater than GetPointCount() then this method will return an empty handle.
*/
- Actor GetHitActor( std::size_t point ) const;
+ Actor GetHitActor(std::size_t point) const;
/**
* @brief Retrieves the co-ordinates relative to the top-left of the hit-actor at the point specified.
* then you should use Actor::ScreenToLocal().
* @note If point is greater than GetPointCount() then this method will return Vector2::ZERO.
*/
- const Vector2& GetLocalPosition( std::size_t point ) const;
+ const Vector2& GetLocalPosition(std::size_t point) const;
/**
* @brief Retrieves the co-ordinates relative to the top-left of the screen of the point specified.
* @return The co-ordinates relative to the top-left of the screen of the point specified
* @note If point is greater than GetPointCount() then this method will return Vector2::ZERO.
*/
- const Vector2& GetScreenPosition( std::size_t point ) const;
+ const Vector2& GetScreenPosition(std::size_t point) const;
/**
* @brief Retrieves the radius of the press point.
* @return The radius of the press point
* @note If point is greater than GetPointCount() then this method will return 0.0f.
*/
- float GetRadius( std::size_t point ) const;
+ float GetRadius(std::size_t point) const;
/**
* @brief Retrieves BOTH the horizontal and the vertical radii of the press point.
* @return The horizontal and vertical radii of the press point
* @note If point is greater than GetPointCount() then this method will return Vector2::ZERO.
*/
- const Vector2& GetEllipseRadius( std::size_t point ) const;
+ const Vector2& GetEllipseRadius(std::size_t point) const;
/**
* @brief Retrieves the touch pressure.
* @return The touch pressure
* @note If point is greater than GetPointCount() then this method will return 1.0f.
*/
- float GetPressure( std::size_t point ) const;
+ float GetPressure(std::size_t point) const;
/**
* @brief Retrieves the angle of the press point relative to the Y-Axis.
* @return The angle of the press point
* @note If point is greater than GetPointCount() then this method will return Degree().
*/
- Degree GetAngle( std::size_t point ) const;
+ Degree GetAngle(std::size_t point) const;
/**
* @brief Gets the device class type from which the mouse/touch event is originated.
* @param[in] point The point required
* @return The type of the device class
*/
- Device::Class::Type GetDeviceClass( std::size_t point ) const;
+ Device::Class::Type GetDeviceClass(std::size_t point) const;
/**
* @brief Gets the subclass type of the device from which the mouse/touch event is originated.
* @param[in] point The point required
* @return The type of the device subclass
*/
- Device::Subclass::Type GetDeviceSubclass( std::size_t point ) const;
-
+ Device::Subclass::Type GetDeviceSubclass(std::size_t point) const;
/**
* @brief Gets the value, which indicates a mouse button. (ex: right/left button)
* @param[in] point The point required
* @return The mouse button value
*/
- MouseButton::Type GetMouseButton( std::size_t point ) const;
-
+ MouseButton::Type GetMouseButton(std::size_t point) const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized TouchEvent handle.
* @SINCE_1_9.26
* @param[in] internal A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL TouchEvent( Internal::TouchEvent* internal );
+ explicit DALI_INTERNAL TouchEvent(Internal::TouchEvent* internal);
/// @endcond
};
namespace Dali
{
-
WheelEvent::WheelEvent()
: BaseHandle()
{
}
-WheelEvent::WheelEvent( const WheelEvent& rhs ) = default;
+WheelEvent::WheelEvent(const WheelEvent& rhs) = default;
-WheelEvent::WheelEvent( WheelEvent&& rhs ) = default;
+WheelEvent::WheelEvent(WheelEvent&& rhs) = default;
WheelEvent::~WheelEvent()
{
}
-WheelEvent& WheelEvent::operator=( const WheelEvent& rhs ) = default;
+WheelEvent& WheelEvent::operator=(const WheelEvent& rhs) = default;
-WheelEvent& WheelEvent::operator=( WheelEvent&& rhs ) = default;
+WheelEvent& WheelEvent::operator=(WheelEvent&& rhs) = default;
bool WheelEvent::IsShiftModifier() const
{
- return GetImplementation( *this ).IsShiftModifier();
+ return GetImplementation(*this).IsShiftModifier();
}
bool WheelEvent::IsCtrlModifier() const
{
- return GetImplementation( *this ).IsCtrlModifier();
+ return GetImplementation(*this).IsCtrlModifier();
}
bool WheelEvent::IsAltModifier() const
{
- return GetImplementation( *this ).IsAltModifier();
+ return GetImplementation(*this).IsAltModifier();
}
WheelEvent::Type WheelEvent::GetType() const
{
- return GetImplementation( *this ).GetType();
+ return GetImplementation(*this).GetType();
}
int32_t WheelEvent::GetDirection() const
{
- return GetImplementation( *this ).GetDirection();
+ return GetImplementation(*this).GetDirection();
}
uint32_t WheelEvent::GetModifiers() const
{
- return GetImplementation( *this ).GetModifiers();
+ return GetImplementation(*this).GetModifiers();
}
const Vector2& WheelEvent::GetPoint() const
{
- return GetImplementation( *this ).GetPoint();
+ return GetImplementation(*this).GetPoint();
}
int32_t WheelEvent::GetDelta() const
{
- return GetImplementation( *this ).GetDelta();
+ return GetImplementation(*this).GetDelta();
}
uint32_t WheelEvent::GetTime() const
{
- return GetImplementation( *this ).GetTime();
+ return GetImplementation(*this).GetTime();
}
-WheelEvent::WheelEvent( Internal::WheelEvent* internal )
-: BaseHandle( internal )
+WheelEvent::WheelEvent(Internal::WheelEvent* internal)
+: BaseHandle(internal)
{
}
namespace Dali
{
-
namespace Internal DALI_INTERNAL
{
class WheelEvent;
*/
class DALI_CORE_API WheelEvent : public BaseHandle
{
-
public:
-
// Enumerations
/**
*/
enum Type
{
- MOUSE_WHEEL, ///< Mouse wheel event @SINCE_1_0.0
- CUSTOM_WHEEL ///< Custom wheel event @SINCE_1_0.0
+ MOUSE_WHEEL, ///< Mouse wheel event @SINCE_1_0.0
+ CUSTOM_WHEEL ///< Custom wheel event @SINCE_1_0.0
};
// Construction & Destruction
* @SINCE_1_9.26
* @param[in] rhs The WheelEvent to copy from
*/
- WheelEvent( const WheelEvent& rhs );
+ WheelEvent(const WheelEvent& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.26
* @param[in] rhs A reference to the moved WheelEvent
*/
- WheelEvent( WheelEvent&& rhs );
+ WheelEvent(WheelEvent&& rhs);
/**
* @brief Destructor.
* @param[in] rhs The WheelEvent to copy from
* @return A reference to this
*/
- WheelEvent& operator=( const WheelEvent& rhs );
+ WheelEvent& operator=(const WheelEvent& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved WheelEvent
* @return A reference to this
*/
- WheelEvent& operator=( WheelEvent&& rhs );
+ WheelEvent& operator=(WheelEvent&& rhs);
/**
* @brief Checks to see if Shift key modifier has been supplied.
uint32_t GetTime() const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used internally to Create an initialized WheelEvent handle.
* @SINCE_1_9.26
* @param[in] wheelEvent A pointer to a newly allocated Dali resource
*/
- explicit DALI_INTERNAL WheelEvent( Internal::WheelEvent* hoverEvent );
+ explicit DALI_INTERNAL WheelEvent(Internal::WheelEvent* hoverEvent);
/// @endcond
};
#define DALI_IMAGE_OPERATIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* This can only be used for images of up to 65535 x 65535 pixels.
* @SINCE_1_0.0
*/
-typedef Dali::Uint16Pair ImageDimensions;
+using ImageDimensions = Dali::Uint16Pair;
/**
* @brief Fitting options, used when resizing images to fit desired dimensions.
*/
namespace FittingMode
{
- /**
+/**
* @brief Enumeration for FittingMode type.
* @SINCE_1_0.0
*/
- enum Type
- {
- SHRINK_TO_FIT, ///< Fit full image inside desired width & height, potentially not
- /// filling one of either the desired image width or height with
- /// pixels.
- /// @SINCE_1_0.0
- SCALE_TO_FILL, ///< Image fills whole desired width & height with image data. The
- /// image is centred in the desired dimensions, exactly touching
- /// in one dimension, with image regions outside the other desired
- /// dimension cropped away.
- /// @SINCE_1_0.0
- FIT_WIDTH, ///< Image fills whole width. Height is scaled proportionately to
- /// maintain aspect ratio.
- /// @SINCE_1_0.0
- FIT_HEIGHT ///< Image fills whole height. Width is scaled proportionately to
- /// maintain aspect ratio.
- /// @SINCE_1_0.0
- };
- const Type DEFAULT = SHRINK_TO_FIT;
-}
+enum Type
+{
+ SHRINK_TO_FIT, ///< Fit full image inside desired width & height, potentially not
+ /// filling one of either the desired image width or height with
+ /// pixels.
+ /// @SINCE_1_0.0
+ SCALE_TO_FILL, ///< Image fills whole desired width & height with image data. The
+ /// image is centred in the desired dimensions, exactly touching
+ /// in one dimension, with image regions outside the other desired
+ /// dimension cropped away.
+ /// @SINCE_1_0.0
+ FIT_WIDTH, ///< Image fills whole width. Height is scaled proportionately to
+ /// maintain aspect ratio.
+ /// @SINCE_1_0.0
+ FIT_HEIGHT ///< Image fills whole height. Width is scaled proportionately to
+ /// maintain aspect ratio.
+ /// @SINCE_1_0.0
+};
+const Type DEFAULT = SHRINK_TO_FIT;
+} // namespace FittingMode
/**
* @brief Filtering options, used when resizing images to sample original pixels.
*/
namespace SamplingMode
{
- /**
+/**
* @brief Enumeration for SamplingMode type.
* @SINCE_1_0.0
*/
- enum Type
- {
- BOX, ///< Iteratively box filter to generate an image of 1/2, 1/4,
- /// 1/8, etc width and height and approximately the desired
- /// size. This is the default.
- /// @SINCE_1_0.0
- NEAREST, ///< For each output pixel, read one input pixel.
- /// @SINCE_1_0.0
- LINEAR, ///< For each output pixel, read a quad of four input pixels
- /// and write a weighted average of them.
- /// @SINCE_1_0.0
- BOX_THEN_NEAREST, ///< Iteratively box filter to generate an image of 1/2, 1/4,
- /// 1/8 etc width and height and approximately the desired
- /// size, then for each output pixel, read one pixel from the
- /// last level of box filtering.
- /// @SINCE_1_0.0
- BOX_THEN_LINEAR, ///< Iteratively box filter to almost the right size, then for
- /// each output pixel, read four pixels from the last level of
- /// box filtering and write their weighted average.
- /// @SINCE_1_0.0
- NO_FILTER, ///< No filtering is performed. If the SCALE_TO_FILL scaling mode
- /// is enabled, the borders of the image may be trimmed to
- /// match the aspect ratio of the desired dimensions.
- /// @SINCE_1_0.0
- DONT_CARE ///< For caching algorithms where a client strongly prefers a
- /// cache-hit to reuse a cached image.
- /// @SINCE_1_0.0
- };
- const Type DEFAULT = BOX;
-}
+enum Type
+{
+ BOX, ///< Iteratively box filter to generate an image of 1/2, 1/4,
+ /// 1/8, etc width and height and approximately the desired
+ /// size. This is the default.
+ /// @SINCE_1_0.0
+ NEAREST, ///< For each output pixel, read one input pixel.
+ /// @SINCE_1_0.0
+ LINEAR, ///< For each output pixel, read a quad of four input pixels
+ /// and write a weighted average of them.
+ /// @SINCE_1_0.0
+ BOX_THEN_NEAREST, ///< Iteratively box filter to generate an image of 1/2, 1/4,
+ /// 1/8 etc width and height and approximately the desired
+ /// size, then for each output pixel, read one pixel from the
+ /// last level of box filtering.
+ /// @SINCE_1_0.0
+ BOX_THEN_LINEAR, ///< Iteratively box filter to almost the right size, then for
+ /// each output pixel, read four pixels from the last level of
+ /// box filtering and write their weighted average.
+ /// @SINCE_1_0.0
+ NO_FILTER, ///< No filtering is performed. If the SCALE_TO_FILL scaling mode
+ /// is enabled, the borders of the image may be trimmed to
+ /// match the aspect ratio of the desired dimensions.
+ /// @SINCE_1_0.0
+ DONT_CARE ///< For caching algorithms where a client strongly prefers a
+ /// cache-hit to reuse a cached image.
+ /// @SINCE_1_0.0
+};
+const Type DEFAULT = BOX;
+} // namespace SamplingMode
/**
* @}
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
-#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/object/any.h>
+#include <dali/public-api/object/ref-object.h>
namespace Dali
{
class NativeImageInterface : public Dali::RefObject
{
public:
-
class Extension; ///< Forward declare future extension interface
/**
*/
virtual uint32_t GetHeight() const = 0;
- /**
+ /**
* @brief Queries whether blending is required.
* @SINCE_1_0.0
* @return True if blending is required
*/
virtual Extension* GetExtension()
{
- return NULL;
+ return nullptr;
}
protected:
-
/**
* @brief A reference counted object may only be deleted by calling Unreference().
*
* The implementation should destroy the NativeImage resources.
* @SINCE_1_0.0
*/
- virtual ~NativeImageInterface()
+ ~NativeImageInterface() override
{
}
-
};
/**
namespace Dali
{
-
-PixelData PixelData::New( uint8_t* buffer,
- uint32_t bufferSize,
- uint32_t width,
- uint32_t height,
- Pixel::Format pixelFormat,
- ReleaseFunction releaseFunction )
+PixelData PixelData::New(uint8_t* buffer,
+ uint32_t bufferSize,
+ uint32_t width,
+ uint32_t height,
+ Pixel::Format pixelFormat,
+ ReleaseFunction releaseFunction)
{
- IntrusivePtr<Internal::PixelData> internal = Internal::PixelData::New( buffer, bufferSize, width, height, pixelFormat, releaseFunction );
- return PixelData( internal.Get() );
+ IntrusivePtr<Internal::PixelData> internal = Internal::PixelData::New(buffer, bufferSize, width, height, pixelFormat, releaseFunction);
+ return PixelData(internal.Get());
}
PixelData::PixelData()
{
}
-PixelData::PixelData( Internal::PixelData* internal )
-: BaseHandle( internal )
+PixelData::PixelData(Internal::PixelData* internal)
+: BaseHandle(internal)
{
}
PixelData& PixelData::operator=(const PixelData& rhs) = default;
-PixelData::PixelData( PixelData&& rhs ) = default;
+PixelData::PixelData(PixelData&& rhs) = default;
-PixelData& PixelData::operator=( PixelData&& rhs ) = default;
+PixelData& PixelData::operator=(PixelData&& rhs) = default;
uint32_t PixelData::GetWidth() const
{
class DALI_CORE_API PixelData : public BaseHandle
{
public:
-
/**
* @brief Enumeration for Function to release the pixel buffer.
* @SINCE_1_1.43
*/
enum ReleaseFunction
{
- FREE, ///< Use free function to release the pixel buffer @SINCE_1_1.43
- DELETE_ARRAY, ///< Use delete[] operator to release the pixel buffer @SINCE_1_1.43
+ FREE, ///< Use free function to release the pixel buffer @SINCE_1_1.43
+ DELETE_ARRAY, ///< Use delete[] operator to release the pixel buffer @SINCE_1_1.43
};
/**
* @param[in] releaseFunction The function used to release the memory
* @return A handle to the PixelData
*/
- static PixelData New( uint8_t* buffer,
- uint32_t bufferSize,
- uint32_t width,
- uint32_t height,
- Pixel::Format pixelFormat,
- ReleaseFunction releaseFunction);
+ static PixelData New(uint8_t* buffer,
+ uint32_t bufferSize,
+ uint32_t width,
+ uint32_t height,
+ Pixel::Format pixelFormat,
+ ReleaseFunction releaseFunction);
/**
* @brief Creates an empty handle.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- PixelData( PixelData&& rhs );
+ PixelData(PixelData&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- PixelData& operator=( PixelData&& rhs );
+ PixelData& operator=(PixelData&& rhs);
/**
* @brief Gets the width of the buffer in pixels.
Pixel::Format GetPixelFormat() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated PixelData
*/
- explicit DALI_INTERNAL PixelData( Internal::PixelData* pointer );
+ explicit DALI_INTERNAL PixelData(Internal::PixelData* pointer);
};
/**
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/images/pixel.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/integration-api/debug.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
-
bool Pixel::HasAlpha(Format pixelformat)
{
- switch (pixelformat)
+ switch(pixelformat)
{
case RGBA5551:
case RGBA8888:
uint32_t Pixel::GetBytesPerPixel(Format pixelFormat)
{
- switch (pixelFormat)
+ switch(pixelFormat)
{
case L8:
case A8:
void Pixel::GetAlphaOffsetAndMask(Format pixelFormat, int& byteOffset, int& bitMask)
{
- switch (pixelFormat)
+ switch(pixelFormat)
{
case A8:
{
case BGR8888:
case BGR565:
{
- byteOffset=0;
- bitMask=0;
+ byteOffset = 0;
+ bitMask = 0;
break;
}
case LA88:
{
- byteOffset=1;
- bitMask=0xff;
+ byteOffset = 1;
+ bitMask = 0xff;
break;
}
case RGBA4444:
case BGRA4444:
{
- byteOffset=1;
- bitMask=0x0f;
+ byteOffset = 1;
+ bitMask = 0x0f;
break;
}
case RGBA5551:
case BGRA5551:
{
- byteOffset=1;
- bitMask=0x01;
+ byteOffset = 1;
+ bitMask = 0x01;
break;
}
case RGBA8888:
case BGRA8888:
{
- byteOffset=3;
- bitMask=0xff;
+ byteOffset = 3;
+ bitMask = 0xff;
break;
}
case INVALID:
{
DALI_LOG_ERROR("Pixel formats are not compatible with simple masking-out of per-pixel alpha.\n");
- byteOffset=0;
- bitMask=0;
+ byteOffset = 0;
+ bitMask = 0;
break;
}
}
#define DALI_PIXEL_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
enum Format
{
- INVALID = 0, ///< Used to represent an unsupported format. @SINCE_1_1.17
+ INVALID = 0, ///< Used to represent an unsupported format. @SINCE_1_1.17
// Start at > 0 to distinguish null data:
- A8 = 1, ///< color depth 8-bit, alpha @SINCE_1_0.0
- L8, ///< color depth 8-bit, luminance @SINCE_1_0.0
- LA88, ///< color depth 16-bit, luminance with 8 bit alpha @SINCE_1_0.0
- RGB565, ///< color depth 16 bit, 5-6-5 @SINCE_1_0.0
- BGR565, ///< color depth 16 bit, 5-6-5 @SINCE_1_0.0
- RGBA4444, ///< color depth 16 bit with alpha, 4-4-4-4 @SINCE_1_0.0
- BGRA4444, ///< color depth 16 bit with alpha, 4-4-4-4 @SINCE_1_0.0
- RGBA5551, ///< color depth 16 bit with alpha, 5-5-5-1 @SINCE_1_0.0
- BGRA5551, ///< color depth 16 bit with alpha, 5-5-5-1 @SINCE_1_0.0
- RGB888, ///< color depth 24 bit, 8-8-8 @SINCE_1_0.0
- RGB8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# @SINCE_1_0.0
- BGR8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# @SINCE_1_0.0
- RGBA8888, ///< color depth 32 bit with alpha, 8-8-8-8 @SINCE_1_0.0
- BGRA8888, ///< color depth 32 bit with alpha, 8-8-8-8 @SINCE_1_0.0
+ A8 = 1, ///< color depth 8-bit, alpha @SINCE_1_0.0
+ L8, ///< color depth 8-bit, luminance @SINCE_1_0.0
+ LA88, ///< color depth 16-bit, luminance with 8 bit alpha @SINCE_1_0.0
+ RGB565, ///< color depth 16 bit, 5-6-5 @SINCE_1_0.0
+ BGR565, ///< color depth 16 bit, 5-6-5 @SINCE_1_0.0
+ RGBA4444, ///< color depth 16 bit with alpha, 4-4-4-4 @SINCE_1_0.0
+ BGRA4444, ///< color depth 16 bit with alpha, 4-4-4-4 @SINCE_1_0.0
+ RGBA5551, ///< color depth 16 bit with alpha, 5-5-5-1 @SINCE_1_0.0
+ BGRA5551, ///< color depth 16 bit with alpha, 5-5-5-1 @SINCE_1_0.0
+ RGB888, ///< color depth 24 bit, 8-8-8 @SINCE_1_0.0
+ RGB8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# @SINCE_1_0.0
+ BGR8888, ///< color depth 32 bit, alpha is reserved but not used, 8-8-8-8# @SINCE_1_0.0
+ RGBA8888, ///< color depth 32 bit with alpha, 8-8-8-8 @SINCE_1_0.0
+ BGRA8888, ///< color depth 32 bit with alpha, 8-8-8-8 @SINCE_1_0.0
// GLES 3 Standard compressed formats:
- COMPRESSED_R11_EAC, ///< ETC2 / EAC single-channel, unsigned @SINCE_1_0.0
- COMPRESSED_SIGNED_R11_EAC, ///< ETC2 / EAC single-channel, signed @SINCE_1_0.0
- COMPRESSED_RG11_EAC, ///< ETC2 / EAC dual-channel, unsigned @SINCE_1_0.0
- COMPRESSED_SIGNED_RG11_EAC, ///< ETC2 / EAC dual-channel, signed @SINCE_1_0.0
- COMPRESSED_RGB8_ETC2, ///< ETC2 / EAC RGB @SINCE_1_0.0
- COMPRESSED_SRGB8_ETC2, ///< ETC2 / EAC RGB using sRGB colourspace. @SINCE_1_0.0
- COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, ///< ETC2 / EAC RGB with single bit per pixel alpha mask. @SINCE_1_0.0
- COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2,///< ETC2 / EAC RGB using sRGB colourspace, with single bit per pixel alpha mask. @SINCE_1_0.0
- COMPRESSED_RGBA8_ETC2_EAC, ///< ETC2 / EAC RGB plus separate alpha channel. @SINCE_1_0.0
- COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, ///< ETC2 / EAC RGB using sRGB colourspace, plus separate alpha channel. @SINCE_1_0.0
+ COMPRESSED_R11_EAC, ///< ETC2 / EAC single-channel, unsigned @SINCE_1_0.0
+ COMPRESSED_SIGNED_R11_EAC, ///< ETC2 / EAC single-channel, signed @SINCE_1_0.0
+ COMPRESSED_RG11_EAC, ///< ETC2 / EAC dual-channel, unsigned @SINCE_1_0.0
+ COMPRESSED_SIGNED_RG11_EAC, ///< ETC2 / EAC dual-channel, signed @SINCE_1_0.0
+ COMPRESSED_RGB8_ETC2, ///< ETC2 / EAC RGB @SINCE_1_0.0
+ COMPRESSED_SRGB8_ETC2, ///< ETC2 / EAC RGB using sRGB colourspace. @SINCE_1_0.0
+ COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, ///< ETC2 / EAC RGB with single bit per pixel alpha mask. @SINCE_1_0.0
+ COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, ///< ETC2 / EAC RGB using sRGB colourspace, with single bit per pixel alpha mask. @SINCE_1_0.0
+ COMPRESSED_RGBA8_ETC2_EAC, ///< ETC2 / EAC RGB plus separate alpha channel. @SINCE_1_0.0
+ COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, ///< ETC2 / EAC RGB using sRGB colourspace, plus separate alpha channel. @SINCE_1_0.0
// GLES 2 extension compressed formats:
- COMPRESSED_RGB8_ETC1, ///< ETC1 RGB as defined by GLES 2 extension OES_compressed_ETC1_RGB8_texture: http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt @SINCE_1_0.0
- COMPRESSED_RGB_PVRTC_4BPPV1, ///< PowerVR 4bpp RGB format (v1) as defined by extension IMG_texture_compression_pvrtc: http://www.khronos.org/registry/gles/extensions/IMG/IMG_texture_compression_pvrtc.txt @SINCE_1_0.0
+ COMPRESSED_RGB8_ETC1, ///< ETC1 RGB as defined by GLES 2 extension OES_compressed_ETC1_RGB8_texture: http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt @SINCE_1_0.0
+ COMPRESSED_RGB_PVRTC_4BPPV1, ///< PowerVR 4bpp RGB format (v1) as defined by extension IMG_texture_compression_pvrtc: http://www.khronos.org/registry/gles/extensions/IMG/IMG_texture_compression_pvrtc.txt @SINCE_1_0.0
// GLES 3.1 compressed formats:
- COMPRESSED_RGBA_ASTC_4x4_KHR, ///< ASTC Linear color space with a 4x4 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_5x4_KHR, ///< ASTC Linear color space with a 5x4 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_5x5_KHR, ///< ASTC Linear color space with a 5x5 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_6x5_KHR, ///< ASTC Linear color space with a 6x5 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_6x6_KHR, ///< ASTC Linear color space with a 6x6 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_8x5_KHR, ///< ASTC Linear color space with a 8x5 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_8x6_KHR, ///< ASTC Linear color space with a 8x6 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_8x8_KHR, ///< ASTC Linear color space with a 8x8 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_10x5_KHR, ///< ASTC Linear color space with a 10x5 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_10x6_KHR, ///< ASTC Linear color space with a 10x6 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_10x8_KHR, ///< ASTC Linear color space with a 10x8 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_10x10_KHR, ///< ASTC Linear color space with a 10x10 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_12x10_KHR, ///< ASTC Linear color space with a 12x10 block-size. @SINCE_1_1.17
- COMPRESSED_RGBA_ASTC_12x12_KHR, ///< ASTC Linear color space with a 12x12 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 4x4 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 5x4 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 5x5 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 6x5 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 6x6 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 8x5 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 8x6 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 8x8 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x5 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x6 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x8 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x10 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 12x10 block-size. @SINCE_1_1.17
- COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 12x12 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_4x4_KHR, ///< ASTC Linear color space with a 4x4 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_5x4_KHR, ///< ASTC Linear color space with a 5x4 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_5x5_KHR, ///< ASTC Linear color space with a 5x5 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_6x5_KHR, ///< ASTC Linear color space with a 6x5 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_6x6_KHR, ///< ASTC Linear color space with a 6x6 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_8x5_KHR, ///< ASTC Linear color space with a 8x5 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_8x6_KHR, ///< ASTC Linear color space with a 8x6 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_8x8_KHR, ///< ASTC Linear color space with a 8x8 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_10x5_KHR, ///< ASTC Linear color space with a 10x5 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_10x6_KHR, ///< ASTC Linear color space with a 10x6 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_10x8_KHR, ///< ASTC Linear color space with a 10x8 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_10x10_KHR, ///< ASTC Linear color space with a 10x10 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_12x10_KHR, ///< ASTC Linear color space with a 12x10 block-size. @SINCE_1_1.17
+ COMPRESSED_RGBA_ASTC_12x12_KHR, ///< ASTC Linear color space with a 12x12 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 4x4 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 5x4 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 5x5 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 6x5 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 6x6 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 8x5 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 8x6 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 8x8 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x5 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x6 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x8 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 10x10 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 12x10 block-size. @SINCE_1_1.17
+ COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, ///< ASTC Non-linear (gamma-corrected) color space with a 12x12 block-size. @SINCE_1_1.17
// GLES 3.0 floating point formats.
RGB16F, ///< Color depth 48-bit, 16-16-16 half floating point. @SINCE_1_2.60
RGB32F, ///< Color depth 96-bit, 32-32-32 floating point. @SINCE_1_2.60
DEPTH_UNSIGNED_INT, ///< Unsigned int depth format 32-bit. @SINCE_1_9.9
- DEPTH_FLOAT, ///< Float depth format 32-bit. @SINCE_1_9.9
+ DEPTH_FLOAT, ///< Float depth format 32-bit. @SINCE_1_9.9
DEPTH_STENCIL ///< Depth stencil 32-bit, 24 bit for depth, 8 bit for stencil. @SINCE_1_9.9
///! Update LAST_VALID_PIXEL_FORMAT below if you add an enum value here.
AngleAxis()
: angle(0.0f),
axis(0.0f, 0.0f, 0.0f)
- { }
+ {
+ }
/**
* @brief Creates an angle-axis pair.
* @param[in] initialAngle The initial angle in radians
* @param[in] initialAxis The initial axis
*/
- AngleAxis( Radian initialAngle, const Vector3& initialAxis )
- : angle( initialAngle ),
- axis( initialAxis )
- { }
+ AngleAxis(Radian initialAngle, const Vector3& initialAxis)
+ : angle(initialAngle),
+ axis(initialAxis)
+ {
+ }
public:
-
- AngleAxis( const AngleAxis& ) = default; ///< Default copy constructor
- AngleAxis( AngleAxis&& ) = default; ///< Default move constructor
- AngleAxis& operator=( const AngleAxis& ) = default; ///< Default copy assignment operator
- AngleAxis& operator=( AngleAxis&& ) = default; ///< Default move assignment operator
+ AngleAxis(const AngleAxis&) = default; ///< Default copy constructor
+ AngleAxis(AngleAxis&&) = default; ///< Default move constructor
+ AngleAxis& operator=(const AngleAxis&) = default; ///< Default copy assignment operator
+ AngleAxis& operator=(AngleAxis&&) = default; ///< Default move assignment operator
public:
-
- Radian angle; ///< The angle in radians
- Vector3 axis; ///< The axis
-
+ Radian angle; ///< The angle in radians
+ Vector3 axis; ///< The axis
};
// Compiler generated destructor, copy constructor and assignment operators are ok as this class is POD
* @param rhs angle axis
* @return True if they are equal
*/
-inline bool operator==( const Dali::AngleAxis& lhs, const Dali::AngleAxis& rhs )
+inline bool operator==(const Dali::AngleAxis& lhs, const Dali::AngleAxis& rhs)
{
return (lhs.angle == rhs.angle) && (lhs.axis == rhs.axis);
}
* @param[in] angleAxis The angle axis to print
* @return The output stream operator
*/
-inline std::ostream& operator<< (std::ostream& o, const Dali::AngleAxis& angleAxis)
+inline std::ostream& operator<<(std::ostream& o, const Dali::AngleAxis& angleAxis)
{
- return o << "[ Axis: [" << angleAxis.axis.x << ", " << angleAxis.axis.y << ", " << angleAxis.axis.z << "], Angle: " << Degree( angleAxis.angle ).degree << " degrees ]";
+ return o << "[ Axis: [" << angleAxis.axis.x << ", " << angleAxis.axis.y << ", " << angleAxis.axis.z << "], Angle: " << Degree(angleAxis.angle).degree << " degrees ]";
}
/**
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
// verification for static asserts, these get removed from final binary by the linker
-static_assert( Power<10,0>::value == 1, "" );
-static_assert( Power<10,1>::value == 10, "" );
-static_assert( Power<10,2>::value == 100, "" );
-static_assert( Power<10,3>::value == 1000, "" );
-static_assert( Power<4,4>::value == 256, "" );
-
-static_assert( Log<0, 10>::value == 0, "" );
-static_assert( Log<1, 10>::value == 0, "" );
-static_assert( Log<2, 10>::value == 1, "" );
-static_assert( Log<10, 10>::value == 1, "" );
-static_assert( Log<100, 10>::value == 2, "" );
-static_assert( Log<1000, 10>::value == 3, "" );
-
-static_assert( Log<Power<10,0>::value, 10 >::value == 0, "" );
-static_assert( Log<Power<2,0>::value, 2 >::value == 0, "" );
-static_assert( Log<Power<10,2>::value, 10 >::value == 2, "" );
-static_assert( Log<Power<2,2>::value, 2 >::value == 2, "" );
-
-static_assert( Power<10, Log<10,10>::value >::value == 10, "" );
-static_assert( Power<10, Log<100,10>::value >::value == 100, "" );
+static_assert(Power<10, 0>::value == 1, "");
+static_assert(Power<10, 1>::value == 10, "");
+static_assert(Power<10, 2>::value == 100, "");
+static_assert(Power<10, 3>::value == 1000, "");
+static_assert(Power<4, 4>::value == 256, "");
+
+static_assert(Log<0, 10>::value == 0, "");
+static_assert(Log<1, 10>::value == 0, "");
+static_assert(Log<2, 10>::value == 1, "");
+static_assert(Log<10, 10>::value == 1, "");
+static_assert(Log<100, 10>::value == 2, "");
+static_assert(Log<1000, 10>::value == 3, "");
+
+static_assert(Log<Power<10, 0>::value, 10>::value == 0, "");
+static_assert(Log<Power<2, 0>::value, 2>::value == 0, "");
+static_assert(Log<Power<10, 2>::value, 10>::value == 2, "");
+static_assert(Log<Power<2, 2>::value, 2>::value == 2, "");
+
+static_assert(Power<10, Log<10, 10>::value>::value == 10, "");
+static_assert(Power<10, Log<100, 10>::value>::value == 100, "");
// TODO unfortunately cannot static assert floats so cannot test EPSILON here...
#define DALI_COMPILE_TIME_MATH_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* @note Values need to be compile time constants.
* Usage: <code>Power< 10, 2 >::value; // value=100</code>
*/
-template< size_t mantissa, size_t exponent >
+template<size_t mantissa, size_t exponent>
struct Power
{
- enum { value = mantissa * Power< mantissa, exponent - 1 >::value };
+ enum
+ {
+ value = mantissa * Power<mantissa, exponent - 1>::value
+ };
};
/**
* @SINCE_1_0.0
* @tparam mantissa to raise to exponent
*/
-template< size_t mantissa >
-struct Power< mantissa, 1 >
+template<size_t mantissa>
+struct Power<mantissa, 1>
{
- enum { value = mantissa };
+ enum
+ {
+ value = mantissa
+ };
};
/**
* @SINCE_1_0.0
* @tparam mantissa to raise to exponent
*/
-template< size_t mantissa >
-struct Power< mantissa, 0 >
+template<size_t mantissa>
+struct Power<mantissa, 0>
{
- enum { value = 1 };
+ enum
+ {
+ value = 1
+ };
};
/**
* @note Values need to be compile time constants.
* Usage: <code>Log< 100, 10 >::value; value equals 2</code>
*/
-template< size_t number, size_t base = 2 >
+template<size_t number, size_t base = 2>
struct Log
{
- enum { value = 1 + Log< number / base, base >::value };
+ enum
+ {
+ value = 1 + Log<number / base, base>::value
+ };
};
/**
* @SINCE_1_0.0
* @tparam base logarithm to calculate
*/
-template< size_t base >
-struct Log< 1, base >
+template<size_t base>
+struct Log<1, base>
{
- enum { value = 0 };
+ enum
+ {
+ value = 0
+ };
};
/**
* @SINCE_1_0.0
* @tparam base logarithm to calculate
*/
-template< size_t base >
-struct Log< 0, base >
+template<size_t base>
+struct Log<0, base>
{
- enum { value = 0 };
+ enum
+ {
+ value = 0
+ };
};
-
/**
* @brief Compiles time template to calculate the machine epsilon for a given floating point number.
*
* @note Value needs to be compile time constant.
* Usage: <code>Epsilon<1000>::value; value equals 0.000119209</code>
*/
-template< size_t N >
+template<size_t N>
struct Epsilon
{
// take log10 of the number to get to the nearest power of 10 number and divide that by 10
// template recursion will take care of the rest
#ifdef _CPP11
- static constexpr float value = 10.0f * Epsilon< Power< 10, Log< N, 10 >::value >::value / 10 >::value;
+ static constexpr float value = 10.0f * Epsilon<Power<10, Log<N, 10>::value>::value / 10>::value;
#else
- static const float value = 10.0f * Epsilon< Power< 10, Log< N, 10 >::value >::value / 10 >::value;
+ static const float value = 10.0f * Epsilon<Power<10, Log<N, 10>::value>::value / 10>::value;
#endif
};
* @SINCE_1_0.0
*/
template<>
-struct Epsilon< 1 >
+struct Epsilon<1>
{
#ifdef _CPP11
static constexpr float value = FLT_EPSILON;
* @SINCE_1_0.0
*/
template<>
-struct Epsilon< 0 >
+struct Epsilon<0>
{
#ifdef _CPP11
static constexpr float value = FLT_MIN;
namespace Dali
{
-
-Degree::Degree( Radian radian )
-: degree( radian * Math::ONE80_OVER_PI )
+Degree::Degree(Radian radian)
+: degree(radian * Math::ONE80_OVER_PI)
{
}
* @SINCE_1_0.0
*/
Degree()
- : degree( 0.f )
- { }
+ : degree(0.f)
+ {
+ }
/**
* @brief Creates an angle in degrees.
* @SINCE_1_0.0
* @param[in] value The initial value in degrees
*/
- explicit constexpr Degree( float value )
- : degree( value )
- { }
+ explicit constexpr Degree(float value)
+ : degree(value)
+ {
+ }
/**
* @brief Creates an angle in degrees from a Radian.
* @SINCE_1_0.0
* @param[in] value The initial value in Radians
*/
- DALI_CORE_API Degree( Radian value );
+ DALI_CORE_API Degree(Radian value);
public:
-
- Degree( const Degree& ) = default; ///< Default copy constructor
- Degree( Degree&& ) = default; ///< Default move constructor
- Degree& operator=( const Degree& ) = default; ///< Default copy assignment operator
- Degree& operator=( Degree&& ) = default; ///< Default move assignment operator
+ Degree(const Degree&) = default; ///< Default copy constructor
+ Degree(Degree&&) = default; ///< Default move constructor
+ Degree& operator=(const Degree&) = default; ///< Default copy assignment operator
+ Degree& operator=(Degree&&) = default; ///< Default move assignment operator
public:
-
// member data
float degree; ///< The value in degrees
-
};
// compiler generated destructor, copy constructor and assignment operators are ok as this class is POD
-
/**
* @brief Compares equality between two degrees.
*
* @param[in] rhs Degree to compare to
* @return True if the values are identical
*/
-inline bool operator==( const Degree& lhs, const Degree& rhs )
+inline bool operator==(const Degree& lhs, const Degree& rhs)
{
- return fabsf( lhs.degree - rhs.degree ) < Math::MACHINE_EPSILON_1000; // expect degree angles to be between 0 and 1000
+ return fabsf(lhs.degree - rhs.degree) < Math::MACHINE_EPSILON_1000; // expect degree angles to be between 0 and 1000
}
/**
* @param[in] rhs Degree to compare to
* @return True if the values are not identical
*/
-inline bool operator!=( const Degree& lhs, const Degree& rhs )
+inline bool operator!=(const Degree& lhs, const Degree& rhs)
{
- return !( operator==( lhs, rhs ) );
+ return !(operator==(lhs, rhs));
}
/**
* @param max value
* @return The resulting radian
*/
-inline Degree Clamp( Degree angle, float min, float max )
+inline Degree Clamp(Degree angle, float min, float max)
{
- return Degree( Clamp<float>( angle.degree, min, max ) );
+ return Degree(Clamp<float>(angle.degree, min, max));
}
/**
#define DALI_MATH_UTILS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <cstdint> // uint32_t
// INTERNAL INCLUDES
-#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/common/constants.h>
+#include <dali/public-api/common/dali-common.h>
namespace Dali
{
* @param[in] i Input number
* @return The next power of two or i itself in case it's a power of two
*/
-inline uint32_t NextPowerOfTwo( uint32_t i )
+inline uint32_t NextPowerOfTwo(uint32_t i)
{
DALI_ASSERT_ALWAYS(i <= 1u << (sizeof(uint32_t) * 8 - 1) && "Return type cannot represent the next power of two greater than the argument.");
- if(i==0u)
+ if(i == 0u)
{
return 1u;
}
* @param[in] i Input number
* @return True if i is power of two.
*/
-inline bool IsPowerOfTwo( uint32_t i )
+inline bool IsPowerOfTwo(uint32_t i)
{
return (i != 0u) && ((i & (i - 1u)) == 0u);
}
* @param[in] max The maximum allowed value.
* @return T the clamped value
*/
-template< typename T >
-inline const T& Clamp( const T& value, const T& min, const T& max )
+template<typename T>
+inline const T& Clamp(const T& value, const T& min, const T& max)
{
- const T& constrainedUpper = value < max ? value : max;
+ const T& constrainedUpper = value < max ? value : max;
const T& constrainedUpperAndLower = constrainedUpper > min ? constrainedUpper : min;
- return constrainedUpperAndLower;
+ return constrainedUpperAndLower;
}
/**
* @param[in] min The minimum allowed value.
* @param[in] max The maximum allowed value.
*/
-template< typename T >
-inline void ClampInPlace( T& value, const T& min, const T& max )
+template<typename T>
+inline void ClampInPlace(T& value, const T& min, const T& max)
{
- const T& constrainedUpper = value < max ? value : max;
+ const T& constrainedUpper = value < max ? value : max;
const T& constrainedUpperAndLower = constrainedUpper > min ? constrainedUpper : min;
- value = constrainedUpperAndLower;
+ value = constrainedUpperAndLower;
}
-
/**
* @brief Linear interpolation between two values.
*
* @param[in] high Highest value in range
* @return A value between low and high.
*/
-template< typename T >
-inline const T Lerp( const float offset, const T& low, const T& high )
+template<typename T>
+inline const T Lerp(const float offset, const T& low, const T& high)
{
return low + ((high - low) * Clamp(offset, 0.0f, 1.0f));
}
* @param[in] b the second value in the range.
* @return a suitable epsilon
*/
-inline float GetRangedEpsilon( float a, float b )
+inline float GetRangedEpsilon(float a, float b)
{
- const float absA = fabsf( a );
- const float absB = fabsf( b );
- const float absF = absA > absB ? absA : absB;
- const int32_t absI = static_cast<int32_t>( absF ); // truncated
+ const float absA = fabsf(a);
+ const float absB = fabsf(b);
+ const float absF = absA > absB ? absA : absB;
+ const int32_t absI = static_cast<int32_t>(absF); // truncated
float epsilon = Math::MACHINE_EPSILON_10000;
- if (absF < 0.1f)
+ if(absF < 0.1f)
{
return Math::MACHINE_EPSILON_0;
}
- else if (absI < 2)
+ else if(absI < 2)
{
return Math::MACHINE_EPSILON_1;
}
- else if (absI < 20)
+ else if(absI < 20)
{
return Math::MACHINE_EPSILON_10;
}
- else if (absI < 200)
+ else if(absI < 200)
{
return Math::MACHINE_EPSILON_100;
}
- else if (absI < 2000)
+ else if(absI < 2000)
{
return Math::MACHINE_EPSILON_1000;
}
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
-inline bool EqualsZero( float value )
+inline bool EqualsZero(float value)
{
return value == 0.0f;
}
* @param[in] b the second value to compare
* @return true if the values are equal within a minimal epsilon for their values
*/
-inline bool Equals( float a, float b )
+inline bool Equals(float a, float b)
{
- return ( fabsf( a - b ) <= GetRangedEpsilon( a, b ) );
+ return (fabsf(a - b) <= GetRangedEpsilon(a, b));
}
/**
* @param[in] epsilon the minimum epsilon value that will be used to consider the values different
* @return true if the difference between the values is less than the epsilon
*/
-inline bool Equals( float a, float b, float epsilon )
+inline bool Equals(float a, float b, float epsilon)
{
- return ( fabsf( a - b ) <= epsilon );
+ return (fabsf(a - b) <= epsilon);
}
/**
* @param[in] pos decimal place
* @return a rounded float
*/
-inline float Round( float value, int32_t pos )
+inline float Round(float value, int32_t pos)
{
float temp;
- temp = value * powf( 10.f, static_cast<float>( pos ) );
- temp = floorf( temp + 0.5f );
- temp *= powf( 10.f, static_cast<float>( -pos ) );
+ temp = value * powf(10.f, static_cast<float>(pos));
+ temp = floorf(temp + 0.5f);
+ temp *= powf(10.f, static_cast<float>(-pos));
return temp;
}
return start;
}
-
/**
* @brief Find the shortest distance (magnitude) and direction (sign)
* from (a) to (b) in domain (start) to (end).
* (start) to (end).
*
*/
-inline float ShortestDistanceInDomain( float a, float b, float start, float end )
+inline float ShortestDistanceInDomain(float a, float b, float start, float end)
{
// (a-start + end-b)
- float size = end-start;
- float vect = b-a;
+ float size = end - start;
+ float vect = b - a;
if(vect > 0)
{
// +ve vector, let's try perspective 1 domain to the right,
// and see if closer.
- float aRight = a+size;
- if( aRight-b < vect )
+ float aRight = a + size;
+ if(aRight - b < vect)
{
- return b-aRight;
+ return b - aRight;
}
}
else
{
// -ve vector, let's try perspective 1 domain to the left,
// and see if closer.
- float aLeft = a-size;
- if( aLeft-b > vect )
+ float aLeft = a - size;
+ if(aLeft - b > vect)
{
- return b-aLeft;
+ return b - aLeft;
}
}
* @param[in] value The value we want to extract the sign
* @return -1 for negative values, +1 for positive values and 0 if value is 0
*/
-template <typename T>
-int32_t Sign( T value )
+template<typename T>
+int32_t Sign(T value)
{
- return ( T(0) < value ) - ( value < T(0) );
+ return (T(0) < value) - (value < T(0));
}
/**
#include <ostream>
// INTERNAL INCLUDES
+#include <dali/internal/render/common/performance-monitor.h>
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/math/math-utils.h>
+#include <dali/public-api/math/quaternion.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/quaternion.h>
-#include <dali/public-api/math/math-utils.h>
-#include <dali/internal/render/common/performance-monitor.h>
namespace
{
const float ROTATION_EPSILON = 0.003f; // Deliberately large
-const uint32_t NUM_BYTES_IN_ROW_OF_3( 3 * sizeof( float ) );
-const uint32_t NUM_BYTES_IN_ROW( 4 * sizeof( float ) );
-const uint32_t NUM_BYTES_IN_MATRIX( 16 * sizeof( float ) );
-const uint32_t ROW1_OFFSET( 4 );
-const uint32_t ROW2_OFFSET( 8 );
-const uint32_t ROW3_OFFSET( 12 );
+const uint32_t NUM_BYTES_IN_ROW_OF_3(3 * sizeof(float));
+const uint32_t NUM_BYTES_IN_ROW(4 * sizeof(float));
+const uint32_t NUM_BYTES_IN_MATRIX(16 * sizeof(float));
+const uint32_t ROW1_OFFSET(4);
+const uint32_t ROW2_OFFSET(8);
+const uint32_t ROW3_OFFSET(12);
/**
* Helper to convert to Quaternion to float16 array
*/
-void Convert( float*& m, const Dali::Quaternion& rotation )
+void Convert(float*& m, const Dali::Quaternion& rotation)
{
const float xx = rotation.mVector.x * rotation.mVector.x;
const float yy = rotation.mVector.y * rotation.mVector.y;
const float wz = rotation.mVector.w * rotation.mVector.z;
const float yz = rotation.mVector.y * rotation.mVector.z;
+ // clang-format off
m[0] = 1.0f - 2.0f * (yy + zz);
m[1] = 2.0f * (xy + wz);
m[2] = 2.0f * (xz - wy);
m[13]= 0.0f;
m[14]= 0.0f;
m[15]= 1.0f;
+ // clang-format on
}
-}
+} // namespace
namespace Dali
{
-
using Internal::PerformanceMonitor;
-const float identityArray[] = {1.0f, 0.0f, 0.0f, 0.0f,
- 0.0f, 1.0f, 0.0f, 0.0f,
- 0.0f, 0.0f, 1.0f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f};
+// clang-format off
+const float identityArray[] = {
+ 1.0f, 0.0f, 0.0f, 0.0f,
+ 0.0f, 1.0f, 0.0f, 0.0f,
+ 0.0f, 0.0f, 1.0f, 0.0f,
+ 0.0f, 0.0f, 0.0f, 1.0f};
+// clang-format on
const Matrix Matrix::IDENTITY(identityArray);
Matrix::Matrix()
{
- memset( mMatrix, 0, NUM_BYTES_IN_MATRIX );
+ memset(mMatrix, 0, NUM_BYTES_IN_MATRIX);
}
-Matrix::Matrix( bool initialize )
+Matrix::Matrix(bool initialize)
{
- if( initialize )
+ if(initialize)
{
- memset( mMatrix, 0, NUM_BYTES_IN_MATRIX );
+ memset(mMatrix, 0, NUM_BYTES_IN_MATRIX);
}
}
Matrix::Matrix(const float* array)
{
- memcpy( mMatrix, array, NUM_BYTES_IN_MATRIX );
+ memcpy(mMatrix, array, NUM_BYTES_IN_MATRIX);
}
-Matrix::Matrix( const Quaternion& rotation )
+Matrix::Matrix(const Quaternion& rotation)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,18);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 18);
float* matrixPtr = &mMatrix[0];
- Convert( matrixPtr, rotation );
+ Convert(matrixPtr, rotation);
}
-Matrix::Matrix( const Matrix& matrix )
+Matrix::Matrix(const Matrix& matrix)
{
- memcpy( mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX );
+ memcpy(mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX);
}
-Matrix& Matrix::operator=( const Matrix& matrix )
+Matrix& Matrix::operator=(const Matrix& matrix)
{
// no point copying if self assigning
- if( this != &matrix )
+ if(this != &matrix)
{
- memcpy( mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX );
+ memcpy(mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX);
}
return *this;
}
-Matrix::Matrix( Matrix&& matrix )
+Matrix::Matrix(Matrix&& matrix)
{
- memcpy( mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX );
+ memcpy(mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX);
}
-Matrix& Matrix::operator=( Matrix&& matrix )
+Matrix& Matrix::operator=(Matrix&& matrix)
{
- if( this != &matrix )
+ if(this != &matrix)
{
- memcpy( mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX );
+ memcpy(mMatrix, matrix.mMatrix, NUM_BYTES_IN_MATRIX);
}
return *this;
}
void Matrix::InvertTransform(Matrix& result) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,12);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 12);
float* m1 = result.AsFloat();
- DALI_ASSERT_ALWAYS( EqualsZero( mMatrix[3] ) && EqualsZero( mMatrix[7] ) && EqualsZero( mMatrix[11] ) && Equals( mMatrix[15], 1.0f ) && "Must be a transform matrix" );
+ DALI_ASSERT_ALWAYS(EqualsZero(mMatrix[3]) && EqualsZero(mMatrix[7]) && EqualsZero(mMatrix[11]) && Equals(mMatrix[15], 1.0f) && "Must be a transform matrix");
m1[0] = mMatrix[0];
m1[1] = mMatrix[4];
m1[6] = mMatrix[9];
m1[7] = 0.0f;
- m1[8] = mMatrix[2];
- m1[9] = mMatrix[6];
+ m1[8] = mMatrix[2];
+ m1[9] = mMatrix[6];
m1[10] = mMatrix[10];
m1[11] = 0.0f;
- m1[12] = -( ( mMatrix[0] * mMatrix[12] ) + ( mMatrix[1] * mMatrix[13] ) + ( mMatrix[2] * mMatrix[14] ) + ( mMatrix[3] * mMatrix[15] ) );
- m1[13] = -( ( mMatrix[4] * mMatrix[12] ) + ( mMatrix[5] * mMatrix[13] ) + ( mMatrix[6] * mMatrix[14] ) + ( mMatrix[7] * mMatrix[15] ) );
- m1[14] = -( ( mMatrix[8] * mMatrix[12] ) + ( mMatrix[9] * mMatrix[13] ) + ( mMatrix[10] * mMatrix[14] ) + ( mMatrix[11] * mMatrix[15] ) );
+ m1[12] = -((mMatrix[0] * mMatrix[12]) + (mMatrix[1] * mMatrix[13]) + (mMatrix[2] * mMatrix[14]) + (mMatrix[3] * mMatrix[15]));
+ m1[13] = -((mMatrix[4] * mMatrix[12]) + (mMatrix[5] * mMatrix[13]) + (mMatrix[6] * mMatrix[14]) + (mMatrix[7] * mMatrix[15]));
+ m1[14] = -((mMatrix[8] * mMatrix[12]) + (mMatrix[9] * mMatrix[13]) + (mMatrix[10] * mMatrix[14]) + (mMatrix[11] * mMatrix[15]));
m1[15] = 1.0f;
}
{
float inv[16];
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,192); // 12 x 16 multiples
-
- inv[0] = m[5]*m[10]*m[15] - m[5]*m[11]*m[14] - m[9]*m[6]*m[15] + m[9]*m[7]*m[14] + m[13]*m[6]*m[11] - m[13]*m[7]*m[10];
- inv[4] = -m[4]*m[10]*m[15] + m[4]*m[11]*m[14] + m[8]*m[6]*m[15] - m[8]*m[7]*m[14] - m[12]*m[6]*m[11] + m[12]*m[7]*m[10];
- inv[8] = m[4]*m[9]*m[15] - m[4]*m[11]*m[13] - m[8]*m[5]*m[15] + m[8]*m[7]*m[13] + m[12]*m[5]*m[11] - m[12]*m[7]*m[9];
- inv[12] = -m[4]*m[9]*m[14] + m[4]*m[10]*m[13] + m[8]*m[5]*m[14] - m[8]*m[6]*m[13] - m[12]*m[5]*m[10] + m[12]*m[6]*m[9];
- inv[1] = -m[1]*m[10]*m[15] + m[1]*m[11]*m[14] + m[9]*m[2]*m[15] - m[9]*m[3]*m[14] - m[13]*m[2]*m[11] + m[13]*m[3]*m[10];
- inv[5] = m[0]*m[10]*m[15] - m[0]*m[11]*m[14] - m[8]*m[2]*m[15] + m[8]*m[3]*m[14] + m[12]*m[2]*m[11] - m[12]*m[3]*m[10];
- inv[9] = -m[0]*m[9]*m[15] + m[0]*m[11]*m[13] + m[8]*m[1]*m[15] - m[8]*m[3]*m[13] - m[12]*m[1]*m[11] + m[12]*m[3]*m[9];
- inv[13] = m[0]*m[9]*m[14] - m[0]*m[10]*m[13] - m[8]*m[1]*m[14] + m[8]*m[2]*m[13] + m[12]*m[1]*m[10] - m[12]*m[2]*m[9];
- inv[2] = m[1]*m[6]*m[15] - m[1]*m[7]*m[14] - m[5]*m[2]*m[15] + m[5]*m[3]*m[14] + m[13]*m[2]*m[7] - m[13]*m[3]*m[6];
- inv[6] = -m[0]*m[6]*m[15] + m[0]*m[7]*m[14] + m[4]*m[2]*m[15] - m[4]*m[3]*m[14] - m[12]*m[2]*m[7] + m[12]*m[3]*m[6];
- inv[10] = m[0]*m[5]*m[15] - m[0]*m[7]*m[13] - m[4]*m[1]*m[15] + m[4]*m[3]*m[13] + m[12]*m[1]*m[7] - m[12]*m[3]*m[5];
- inv[14] = -m[0]*m[5]*m[14] + m[0]*m[6]*m[13] + m[4]*m[1]*m[14] - m[4]*m[2]*m[13] - m[12]*m[1]*m[6] + m[12]*m[2]*m[5];
- inv[3] = -m[1]*m[6]*m[11] + m[1]*m[7]*m[10] + m[5]*m[2]*m[11] - m[5]*m[3]*m[10] - m[9]*m[2]*m[7] + m[9]*m[3]*m[6];
- inv[7] = m[0]*m[6]*m[11] - m[0]*m[7]*m[10] - m[4]*m[2]*m[11] + m[4]*m[3]*m[10] + m[8]*m[2]*m[7] - m[8]*m[3]*m[6];
- inv[11] = -m[0]*m[5]*m[11] + m[0]*m[7]*m[9] + m[4]*m[1]*m[11] - m[4]*m[3]*m[9] - m[8]*m[1]*m[7] + m[8]*m[3]*m[5];
- inv[15] = m[0]*m[5]*m[10] - m[0]*m[6]*m[9] - m[4]*m[1]*m[10] + m[4]*m[2]*m[9] + m[8]*m[1]*m[6] - m[8]*m[2]*m[5];
-
- float det = m[0]*inv[0] + m[1]*inv[4] + m[2]*inv[8] + m[3]*inv[12];
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 192); // 12 x 16 multiples
+
+ inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
+ inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
+ inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
+ inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
+ inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
+ inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
+ inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
+ inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
+ inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
+ inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
+ inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
+ inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
+ inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
+ inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
+ inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
+ inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
+
+ float det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
// In the case where the determinant is exactly zero, the matrix is non-invertible
- if ( EqualsZero( det ) )
+ if(EqualsZero(det))
{
return false;
}
det = 1.0f / det;
- for( int32_t i = 0; i < 16; i++)
+ for(int32_t i = 0; i < 16; i++)
{
out[i] = inv[i] * det;
}
mMatrix[1] = mMatrix[4];
mMatrix[4] = temp;
- temp = mMatrix[2];
+ temp = mMatrix[2];
mMatrix[2] = mMatrix[8];
mMatrix[8] = temp;
- temp = mMatrix[3];
- mMatrix[3] = mMatrix[12];
+ temp = mMatrix[3];
+ mMatrix[3] = mMatrix[12];
mMatrix[12] = temp;
- temp = mMatrix[6];
+ temp = mMatrix[6];
mMatrix[6] = mMatrix[9];
mMatrix[9] = temp;
- temp = mMatrix[7];
- mMatrix[7] = mMatrix[13];
+ temp = mMatrix[7];
+ mMatrix[7] = mMatrix[13];
mMatrix[13] = temp;
- temp = mMatrix[11];
+ temp = mMatrix[11];
mMatrix[11] = mMatrix[14];
mMatrix[14] = temp;
}
void Matrix::SetIdentity()
{
- memcpy( mMatrix, identityArray, NUM_BYTES_IN_MATRIX );
+ memcpy(mMatrix, identityArray, NUM_BYTES_IN_MATRIX);
}
-void Matrix::SetIdentityAndScale( const Vector3& scale )
+void Matrix::SetIdentityAndScale(const Vector3& scale)
{
// initialize to zeros
- memset( mMatrix, 0, NUM_BYTES_IN_MATRIX );
+ memset(mMatrix, 0, NUM_BYTES_IN_MATRIX);
// just apply scale on the diagonal
mMatrix[0] = scale.x;
void Matrix::SetTranslation(const Vector4& translation)
{
- memcpy( mMatrix + ROW3_OFFSET, &translation, NUM_BYTES_IN_ROW );
+ memcpy(mMatrix + ROW3_OFFSET, &translation, NUM_BYTES_IN_ROW);
}
void Matrix::SetTranslation(const Vector3& other)
{
- memcpy( mMatrix + ROW3_OFFSET, &other, NUM_BYTES_IN_ROW_OF_3 );
+ memcpy(mMatrix + ROW3_OFFSET, &other, NUM_BYTES_IN_ROW_OF_3);
mMatrix[15] = 1.0f;
}
-void Matrix::Multiply( Matrix& result, const Matrix& lhs, const Matrix& rhs )
+void Matrix::Multiply(Matrix& result, const Matrix& lhs, const Matrix& rhs)
{
MATH_INCREASE_COUNTER(PerformanceMonitor::MATRIX_MULTIPLYS);
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,64); // 64 = 16*4
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 64); // 64 = 16*4
- float* temp = result.AsFloat();
- const float* rhsPtr = rhs.AsFloat();
+ float* temp = result.AsFloat();
+ const float* rhsPtr = rhs.AsFloat();
const float* lhsPtr = lhs.AsFloat();
-#ifndef __ARM_NEON__
+#ifndef __ARM_NEON__
- for( int32_t i=0; i < 4; i++ )
+ for(int32_t i = 0; i < 4; i++)
{
// i<<2 gives the first vector / column
- int32_t loc = i<<2;
- int32_t loc1 = loc + 1;
- int32_t loc2 = loc + 2;
- int32_t loc3 = loc + 3;
- float value0 = lhsPtr[loc];
- float value1 = lhsPtr[loc1];
- float value2 = lhsPtr[loc2];
- float value3 = lhsPtr[loc3];
- temp[loc] = (value0 * rhsPtr[0]) +
- (value1 * rhsPtr[4]) +
- (value2 * rhsPtr[8]) +
- (value3 * rhsPtr[12]);
+ int32_t loc = i << 2;
+ int32_t loc1 = loc + 1;
+ int32_t loc2 = loc + 2;
+ int32_t loc3 = loc + 3;
+ float value0 = lhsPtr[loc];
+ float value1 = lhsPtr[loc1];
+ float value2 = lhsPtr[loc2];
+ float value3 = lhsPtr[loc3];
+
+ temp[loc] = (value0 * rhsPtr[0]) +
+ (value1 * rhsPtr[4]) +
+ (value2 * rhsPtr[8]) +
+ (value3 * rhsPtr[12]);
temp[loc1] = (value0 * rhsPtr[1]) +
(value1 * rhsPtr[5]) +
temp[loc2] = (value0 * rhsPtr[2]) +
(value1 * rhsPtr[6]) +
- (value2 * rhsPtr[10])+
+ (value2 * rhsPtr[10]) +
(value3 * rhsPtr[14]);
temp[loc3] = (value0 * rhsPtr[3]) +
(value1 * rhsPtr[7]) +
- (value2 * rhsPtr[11])+
+ (value2 * rhsPtr[11]) +
(value3 * rhsPtr[15]);
}
// e.g. q0 = d0 and d1
// load and stores interleaved as NEON can load and store while calculating
- asm volatile ( "VLDM %1, {q0-q3} \n\t" // load matrix 1 (lhsPtr) q[0..q3]
- "VLDM %0, {q8-q11} \n\t" // load matrix 2 (rhsPtr) q[q8-q11]
- "VMUL.F32 q12, q8, d0[0] \n\t" // column 0 = rhsPtr[0..3] * lhsPtr[0..3]
- "VMUL.F32 q13, q8, d2[0] \n\t" // column 1 = rhsPtr[0..3] * lhsPtr[4..7]
- "VMUL.F32 q14, q8, d4[0] \n\t" // column 2 = rhsPtr[0..3] * lhsPtr[8..11]
- "VMUL.F32 q15, q8, d6[0] \n\t" // column 3 = rhsPtr[0..3] * lhsPtr[12..15]
-
- "VMLA.F32 q12, q9, d0[1] \n\t" // column 0 += rhsPtr[4..7] * lhsPtr[0..3]
- "VMLA.F32 q13, q9, d2[1] \n\t" // column 1 += rhsPtr[4..7] * lhsPtr[4..7]
- "VMLA.F32 q14, q9, d4[1] \n\t" // column 2 += rhsPtr[4..7] * lhsPtr[8..11]
- "VMLA.F32 q15, q9, d6[1] \n\t" // column 3 += rhsPtr[4..7] * lhsPtr[12..15]
-
- "VMLA.F32 q12, q10, d1[0] \n\t" // column 0 += rhsPtr[8..11] * lhsPtr[0..3]
- "VMLA.F32 q13, q10, d3[0] \n\t" // column 1 += rhsPtr[8..11] * lhsPtr[4..7]
- "VMLA.F32 q14, q10, d5[0] \n\t" // column 2 += rhsPtr[8..11] * lhsPtr[8..11]
- "VMLA.F32 q15, q10, d7[0] \n\t" // column 3 += rhsPtr[8..11] * lhsPtr[12..15]
-
- "VMLA.F32 q12, q11, d1[1] \n\t" // column 0 += rhsPtr[12..15] * lhsPtr[0..3]
- "VMLA.F32 q13, q11, d3[1] \n\t" // column 1 += rhsPtr[12..15] * lhsPtr[4..7]
- "VMLA.F32 q14, q11, d5[1] \n\t" // column 2 += rhsPtr[12..15] * lhsPtr[8..11]
- "VMLA.F32 q15, q11, d7[1] \n\t" // column 3 += rhsPtr[12..15] * lhsPtr[12..15]
- "VSTM %2, {q12-q15} \n\t" // store entire output matrix.
- : "+r"(rhsPtr), "+r"(lhsPtr), "+r"(temp)
- :
- : "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15", "memory" );
+ asm volatile(
+ "VLDM %1, {q0-q3} \n\t" // load matrix 1 (lhsPtr) q[0..q3]
+ "VLDM %0, {q8-q11} \n\t" // load matrix 2 (rhsPtr) q[q8-q11]
+ "VMUL.F32 q12, q8, d0[0] \n\t" // column 0 = rhsPtr[0..3] * lhsPtr[0..3]
+ "VMUL.F32 q13, q8, d2[0] \n\t" // column 1 = rhsPtr[0..3] * lhsPtr[4..7]
+ "VMUL.F32 q14, q8, d4[0] \n\t" // column 2 = rhsPtr[0..3] * lhsPtr[8..11]
+ "VMUL.F32 q15, q8, d6[0] \n\t" // column 3 = rhsPtr[0..3] * lhsPtr[12..15]
+
+ "VMLA.F32 q12, q9, d0[1] \n\t" // column 0 += rhsPtr[4..7] * lhsPtr[0..3]
+ "VMLA.F32 q13, q9, d2[1] \n\t" // column 1 += rhsPtr[4..7] * lhsPtr[4..7]
+ "VMLA.F32 q14, q9, d4[1] \n\t" // column 2 += rhsPtr[4..7] * lhsPtr[8..11]
+ "VMLA.F32 q15, q9, d6[1] \n\t" // column 3 += rhsPtr[4..7] * lhsPtr[12..15]
+
+ "VMLA.F32 q12, q10, d1[0] \n\t" // column 0 += rhsPtr[8..11] * lhsPtr[0..3]
+ "VMLA.F32 q13, q10, d3[0] \n\t" // column 1 += rhsPtr[8..11] * lhsPtr[4..7]
+ "VMLA.F32 q14, q10, d5[0] \n\t" // column 2 += rhsPtr[8..11] * lhsPtr[8..11]
+ "VMLA.F32 q15, q10, d7[0] \n\t" // column 3 += rhsPtr[8..11] * lhsPtr[12..15]
+
+ "VMLA.F32 q12, q11, d1[1] \n\t" // column 0 += rhsPtr[12..15] * lhsPtr[0..3]
+ "VMLA.F32 q13, q11, d3[1] \n\t" // column 1 += rhsPtr[12..15] * lhsPtr[4..7]
+ "VMLA.F32 q14, q11, d5[1] \n\t" // column 2 += rhsPtr[12..15] * lhsPtr[8..11]
+ "VMLA.F32 q15, q11, d7[1] \n\t" // column 3 += rhsPtr[12..15] * lhsPtr[12..15]
+ "VSTM %2, {q12-q15} \n\t" // store entire output matrix.
+ : "+r"(rhsPtr), "+r"(lhsPtr), "+r"(temp)
+ :
+ : "q0", "q1", "q2", "q3", "q8", "q9", "q10", "q11", "q12", "q13", "q14", "q15", "memory");
#endif
}
-void Matrix::Multiply( Matrix& result, const Matrix& lhs, const Quaternion& rhs )
+void Matrix::Multiply(Matrix& result, const Matrix& lhs, const Quaternion& rhs)
{
MATH_INCREASE_COUNTER(PerformanceMonitor::MATRIX_MULTIPLYS);
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,54); // 54 = 36+18
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 54); // 54 = 36+18
- float matrix[16];
+ float matrix[16];
float* rhsPtr = &matrix[0];
- Convert( rhsPtr, rhs );
+ Convert(rhsPtr, rhs);
// quaternion contains just rotation so it really only needs 3x3 matrix
- float* temp = result.AsFloat();
+ float* temp = result.AsFloat();
const float* lhsPtr = lhs.AsFloat();
-#ifndef __ARM_NEON__
+#ifndef __ARM_NEON__
- for( int32_t i=0; i < 4; i++ )
+ for(int32_t i = 0; i < 4; i++)
{
// i<<2 gives the first vector / column
- int32_t loc = i<<2;
- int32_t loc1 = loc + 1;
- int32_t loc2 = loc + 2;
- int32_t loc3 = loc + 3;
- float value0 = lhsPtr[loc];
- float value1 = lhsPtr[loc1];
- float value2 = lhsPtr[loc2];
- float value3 = lhsPtr[loc3];
- temp[loc] = (value0 * rhsPtr[0]) +
- (value1 * rhsPtr[4]) +
- (value2 * rhsPtr[8]) +
- (0.0f); //value3 * rhsPtr[12] is 0.0f
+ int32_t loc = i << 2;
+ int32_t loc1 = loc + 1;
+ int32_t loc2 = loc + 2;
+ int32_t loc3 = loc + 3;
+ float value0 = lhsPtr[loc];
+ float value1 = lhsPtr[loc1];
+ float value2 = lhsPtr[loc2];
+ float value3 = lhsPtr[loc3];
+
+ temp[loc] = (value0 * rhsPtr[0]) +
+ (value1 * rhsPtr[4]) +
+ (value2 * rhsPtr[8]) +
+ (0.0f); //value3 * rhsPtr[12] is 0.0f
temp[loc1] = (value0 * rhsPtr[1]) +
(value1 * rhsPtr[5]) +
temp[loc2] = (value0 * rhsPtr[2]) +
(value1 * rhsPtr[6]) +
- (value2 * rhsPtr[10])+
+ (value2 * rhsPtr[10]) +
(0.0f); //value3 * rhsPtr[14] is 0.0f
- temp[loc3] = (0.0f) + //value0 * rhsPtr[3] is 0.0f
- (0.0f) + //value1 * rhsPtr[7] is 0.0f
- (0.0f) + //value2 * rhsPtr[11] is 0.0f
+ temp[loc3] = (0.0f) + //value0 * rhsPtr[3] is 0.0f
+ (0.0f) + //value1 * rhsPtr[7] is 0.0f
+ (0.0f) + //value2 * rhsPtr[11] is 0.0f
(value3); // rhsPtr[15] is 1.0f
}
// q =128 bit quad-word q0 -q15 (enough to handle a column of 4 floats in a matrix)
// e.g. q0 = d0 and d1
// load and stores interleaved as NEON can load and store while calculating
- asm volatile ( "VLDM %1, {q4-q6} \n\t" // load matrix 1 (lhsPtr)
- "VLD1.F32 {q7}, [%2]! \n\t" // load matrix 2 (rhsPtr) [0..3]
- "VMUL.F32 q0, q7, d8[0] \n\t" // column 0 = rhsPtr[0..3] * lhsPtr[0..3]
- "VMUL.F32 q1, q7, d10[0] \n\t" // column 1 = rhsPtr[0..3] * lhsPtr[4..7]
- "VMUL.F32 q2, q7, d12[0] \n\t" // column 2 = rhsPtr[0..3] * lhsPtr[8..11]
- "VLD1.F32 {q7}, [%2]! \n\t" // load matrix 2 (rhsPtr) [4..7]
- "VMLA.F32 q0, q7, d8[1] \n\t" // column 0+= rhsPtr[4..7] * lhsPtr[0..3]
- "VMLA.F32 q1, q7, d10[1] \n\t" // column 1+= rhsPtr[4..7] * lhsPtr[4..7]
- "VMLA.F32 q2, q7, d12[1] \n\t" // column 2+= rhsPtr[4..7] * lhsPtr[8..11]
- "VLD1.F32 {q7}, [%2]! \n\t" // load matrix 2 (rhsPtr) [8..11]
- "VMLA.F32 q0, q7, d9[0] \n\t" // column 0+= rhsPtr[8..11] * lhsPtr[0..3]
- "VMLA.F32 q1, q7, d11[0] \n\t" // column 1+= rhsPtr[8..11] * lhsPtr[4..7]
- "VMLA.F32 q2, q7, d13[0] \n\t" // column 2+= rhsPtr[8..11] * lhsPtr[8..11]
- "VSTM %0, {q0-q2} \n\t" // store entire output matrix.
- :
- : "r"(temp), "r"(lhsPtr), "r" (rhsPtr)
- : "%r0", "%q0", "%q1", "%q2", "%q4", "%q5", "%q6", "%q7", "memory" );
-
- temp[ 12 ] = 0.0f;
- temp[ 13 ] = 0.0f;
- temp[ 14 ] = 0.0f;
- temp[ 15 ] = 1.0f;
+ asm volatile(
+ "VLDM %1, {q4-q6} \n\t" // load matrix 1 (lhsPtr)
+ "VLD1.F32 {q7}, [%2]! \n\t" // load matrix 2 (rhsPtr) [0..3]
+ "VMUL.F32 q0, q7, d8[0] \n\t" // column 0 = rhsPtr[0..3] * lhsPtr[0..3]
+ "VMUL.F32 q1, q7, d10[0] \n\t" // column 1 = rhsPtr[0..3] * lhsPtr[4..7]
+ "VMUL.F32 q2, q7, d12[0] \n\t" // column 2 = rhsPtr[0..3] * lhsPtr[8..11]
+ "VLD1.F32 {q7}, [%2]! \n\t" // load matrix 2 (rhsPtr) [4..7]
+ "VMLA.F32 q0, q7, d8[1] \n\t" // column 0+= rhsPtr[4..7] * lhsPtr[0..3]
+ "VMLA.F32 q1, q7, d10[1] \n\t" // column 1+= rhsPtr[4..7] * lhsPtr[4..7]
+ "VMLA.F32 q2, q7, d12[1] \n\t" // column 2+= rhsPtr[4..7] * lhsPtr[8..11]
+ "VLD1.F32 {q7}, [%2]! \n\t" // load matrix 2 (rhsPtr) [8..11]
+ "VMLA.F32 q0, q7, d9[0] \n\t" // column 0+= rhsPtr[8..11] * lhsPtr[0..3]
+ "VMLA.F32 q1, q7, d11[0] \n\t" // column 1+= rhsPtr[8..11] * lhsPtr[4..7]
+ "VMLA.F32 q2, q7, d13[0] \n\t" // column 2+= rhsPtr[8..11] * lhsPtr[8..11]
+ "VSTM %0, {q0-q2} \n\t" // store entire output matrix.
+ :
+ : "r"(temp), "r"(lhsPtr), "r"(rhsPtr)
+ : "%r0", "%q0", "%q1", "%q2", "%q4", "%q5", "%q6", "%q7", "memory");
+
+ temp[12] = 0.0f;
+ temp[13] = 0.0f;
+ temp[14] = 0.0f;
+ temp[15] = 1.0f;
#endif
}
Vector4 Matrix::operator*(const Vector4& rhs) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,16);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 16);
Vector4 temp;
-#ifndef __ARM_NEON__
+#ifndef __ARM_NEON__
- temp.x = rhs.x * mMatrix[0] + rhs.y * mMatrix[4] + rhs.z * mMatrix[8] + rhs.w * mMatrix[12];
- temp.y = rhs.x * mMatrix[1] + rhs.y * mMatrix[5] + rhs.z * mMatrix[9] + rhs.w * mMatrix[13];
- temp.z = rhs.x * mMatrix[2] + rhs.y * mMatrix[6] + rhs.z * mMatrix[10] + rhs.w * mMatrix[14];
- temp.w = rhs.x * mMatrix[3] + rhs.y * mMatrix[7] + rhs.z * mMatrix[11] + rhs.w * mMatrix[15];
+ temp.x = rhs.x * mMatrix[0] + rhs.y * mMatrix[4] + rhs.z * mMatrix[8] + rhs.w * mMatrix[12];
+ temp.y = rhs.x * mMatrix[1] + rhs.y * mMatrix[5] + rhs.z * mMatrix[9] + rhs.w * mMatrix[13];
+ temp.z = rhs.x * mMatrix[2] + rhs.y * mMatrix[6] + rhs.z * mMatrix[10] + rhs.w * mMatrix[14];
+ temp.w = rhs.x * mMatrix[3] + rhs.y * mMatrix[7] + rhs.z * mMatrix[11] + rhs.w * mMatrix[15];
#else
// q =128 bit quad-word q0 -q15 (enough to handle a column of 4 floats in a matrix)
// e.g. q0 = d0 and d1
// load and stores interleaved as NEON can load and store while calculating
- asm volatile ( "VLD1.F32 {q0}, [%1] \n\t" //q0 = rhs
- "VLD1.F32 {q9}, [%0]! \n\t"
- "VMUL.F32 q10, q9, d0[0] \n\t"
- "VLD1.F32 {q9}, [%0]! \n\t"
- "VMLA.F32 q10, q9, d0[1] \n\t" //q10 = mMatrix[0..3] * rhs + mMatrix[4..7] * rhs
- "VLD1.F32 {q9}, [%0]! \n\t"
- "VMUL.F32 q11, q9, d1[0] \n\t"
- "VLD1.F32 {q9}, [%0]! \n\t"
- "VMLA.F32 q11, q9, d1[1] \n\t" //q11 = mMatrix[8..11] * rhs + mMatrix[12..15] * rhs
- "VADD.F32 q10, q10, q11 \n\t"
- "VST1.F32 {q10},[%2] \n\t" //temp = q10 + q11
- :
- : "r"(mMatrix), "r"(&rhs), "r"(&temp)
- : "q0", "q9", "q10", "q11", "memory" );
+ asm volatile(
+ "VLD1.F32 {q0}, [%1] \n\t" //q0 = rhs
+ "VLD1.F32 {q9}, [%0]! \n\t"
+ "VMUL.F32 q10, q9, d0[0] \n\t"
+ "VLD1.F32 {q9}, [%0]! \n\t"
+ "VMLA.F32 q10, q9, d0[1] \n\t" //q10 = mMatrix[0..3] * rhs + mMatrix[4..7] * rhs
+ "VLD1.F32 {q9}, [%0]! \n\t"
+ "VMUL.F32 q11, q9, d1[0] \n\t"
+ "VLD1.F32 {q9}, [%0]! \n\t"
+ "VMLA.F32 q11, q9, d1[1] \n\t" //q11 = mMatrix[8..11] * rhs + mMatrix[12..15] * rhs
+ "VADD.F32 q10, q10, q11 \n\t"
+ "VST1.F32 {q10},[%2] \n\t" //temp = q10 + q11
+ :
+ : "r"(mMatrix), "r"(&rhs), "r"(&temp)
+ : "q0", "q9", "q10", "q11", "memory");
#endif
return temp;
}
bool Matrix::operator==(const Matrix& rhs) const
{
return (
- ( fabsf( mMatrix[0] - rhs.mMatrix[0] ) <= GetRangedEpsilon( mMatrix[0], rhs.mMatrix[0] ) ) &&
- ( fabsf( mMatrix[1] - rhs.mMatrix[1] ) <= GetRangedEpsilon( mMatrix[1], rhs.mMatrix[1] ) ) &&
- ( fabsf( mMatrix[2] - rhs.mMatrix[2] ) <= GetRangedEpsilon( mMatrix[2], rhs.mMatrix[2] ) ) &&
- ( fabsf( mMatrix[3] - rhs.mMatrix[3] ) <= GetRangedEpsilon( mMatrix[3], rhs.mMatrix[3] ) ) &&
- ( fabsf( mMatrix[4] - rhs.mMatrix[4] ) <= GetRangedEpsilon( mMatrix[4], rhs.mMatrix[4] ) ) &&
- ( fabsf( mMatrix[5] - rhs.mMatrix[5] ) <= GetRangedEpsilon( mMatrix[5], rhs.mMatrix[5] ) ) &&
- ( fabsf( mMatrix[6] - rhs.mMatrix[6] ) <= GetRangedEpsilon( mMatrix[6], rhs.mMatrix[6] ) ) &&
- ( fabsf( mMatrix[7] - rhs.mMatrix[7] ) <= GetRangedEpsilon( mMatrix[7], rhs.mMatrix[7] ) ) &&
- ( fabsf( mMatrix[8] - rhs.mMatrix[8] ) <= GetRangedEpsilon( mMatrix[8], rhs.mMatrix[8] ) ) &&
- ( fabsf( mMatrix[9] - rhs.mMatrix[9] ) <= GetRangedEpsilon( mMatrix[9], rhs.mMatrix[9] ) ) &&
- ( fabsf( mMatrix[10] - rhs.mMatrix[10] ) <= GetRangedEpsilon( mMatrix[10], rhs.mMatrix[10] ) ) &&
- ( fabsf( mMatrix[11] - rhs.mMatrix[11] ) <= GetRangedEpsilon( mMatrix[11], rhs.mMatrix[11] ) ) &&
- ( fabsf( mMatrix[12] - rhs.mMatrix[12] ) <= GetRangedEpsilon( mMatrix[12], rhs.mMatrix[12] ) ) &&
- ( fabsf( mMatrix[13] - rhs.mMatrix[13] ) <= GetRangedEpsilon( mMatrix[13], rhs.mMatrix[13] ) ) &&
- ( fabsf( mMatrix[14] - rhs.mMatrix[14] ) <= GetRangedEpsilon( mMatrix[14], rhs.mMatrix[14] ) ) &&
- ( fabsf( mMatrix[15] - rhs.mMatrix[15] ) <= GetRangedEpsilon( mMatrix[15], rhs.mMatrix[15] ) ) );
+ (fabsf(mMatrix[0] - rhs.mMatrix[0]) <= GetRangedEpsilon(mMatrix[0], rhs.mMatrix[0])) &&
+ (fabsf(mMatrix[1] - rhs.mMatrix[1]) <= GetRangedEpsilon(mMatrix[1], rhs.mMatrix[1])) &&
+ (fabsf(mMatrix[2] - rhs.mMatrix[2]) <= GetRangedEpsilon(mMatrix[2], rhs.mMatrix[2])) &&
+ (fabsf(mMatrix[3] - rhs.mMatrix[3]) <= GetRangedEpsilon(mMatrix[3], rhs.mMatrix[3])) &&
+ (fabsf(mMatrix[4] - rhs.mMatrix[4]) <= GetRangedEpsilon(mMatrix[4], rhs.mMatrix[4])) &&
+ (fabsf(mMatrix[5] - rhs.mMatrix[5]) <= GetRangedEpsilon(mMatrix[5], rhs.mMatrix[5])) &&
+ (fabsf(mMatrix[6] - rhs.mMatrix[6]) <= GetRangedEpsilon(mMatrix[6], rhs.mMatrix[6])) &&
+ (fabsf(mMatrix[7] - rhs.mMatrix[7]) <= GetRangedEpsilon(mMatrix[7], rhs.mMatrix[7])) &&
+ (fabsf(mMatrix[8] - rhs.mMatrix[8]) <= GetRangedEpsilon(mMatrix[8], rhs.mMatrix[8])) &&
+ (fabsf(mMatrix[9] - rhs.mMatrix[9]) <= GetRangedEpsilon(mMatrix[9], rhs.mMatrix[9])) &&
+ (fabsf(mMatrix[10] - rhs.mMatrix[10]) <= GetRangedEpsilon(mMatrix[10], rhs.mMatrix[10])) &&
+ (fabsf(mMatrix[11] - rhs.mMatrix[11]) <= GetRangedEpsilon(mMatrix[11], rhs.mMatrix[11])) &&
+ (fabsf(mMatrix[12] - rhs.mMatrix[12]) <= GetRangedEpsilon(mMatrix[12], rhs.mMatrix[12])) &&
+ (fabsf(mMatrix[13] - rhs.mMatrix[13]) <= GetRangedEpsilon(mMatrix[13], rhs.mMatrix[13])) &&
+ (fabsf(mMatrix[14] - rhs.mMatrix[14]) <= GetRangedEpsilon(mMatrix[14], rhs.mMatrix[14])) &&
+ (fabsf(mMatrix[15] - rhs.mMatrix[15]) <= GetRangedEpsilon(mMatrix[15], rhs.mMatrix[15])));
}
bool Matrix::operator!=(const Matrix& rhs) const
{
- if (*this == rhs)
+ if(*this == rhs)
{
return false;
}
vector0.Normalize();
vector1.Normalize();
- vector2 = vector0.Cross( vector1 );
- vector1 = vector2.Cross( vector0 );
+ vector2 = vector0.Cross(vector1);
+ vector1 = vector2.Cross(vector0);
- memcpy( mMatrix, &vector0, NUM_BYTES_IN_ROW );
- memcpy( mMatrix + ROW1_OFFSET, &vector1, NUM_BYTES_IN_ROW );
- memcpy( mMatrix + ROW2_OFFSET, &vector2, NUM_BYTES_IN_ROW );
+ memcpy(mMatrix, &vector0, NUM_BYTES_IN_ROW);
+ memcpy(mMatrix + ROW1_OFFSET, &vector1, NUM_BYTES_IN_ROW);
+ memcpy(mMatrix + ROW2_OFFSET, &vector2, NUM_BYTES_IN_ROW);
}
Vector3 Matrix::GetXAxis() const
void Matrix::SetZAxis(const Vector3& axis)
{
- mMatrix[8] = axis.x;
- mMatrix[9] = axis.y;
+ mMatrix[8] = axis.x;
+ mMatrix[9] = axis.y;
mMatrix[10] = axis.z;
}
void Matrix::SetTransformComponents(const Vector3& scale,
const Quaternion& rotation,
- const Vector3& translation )
+ const Vector3& translation)
{
- if( rotation.IsIdentity() )
+ if(rotation.IsIdentity())
{
mMatrix[0] = scale.x;
mMatrix[1] = 0.0f;
mMatrix[6] = 0.0f;
mMatrix[7] = 0.0f;
- mMatrix[8] = 0.0f;
- mMatrix[9] = 0.0f;
- mMatrix[10]= scale.z;
- mMatrix[11]= 0.0f;
+ mMatrix[8] = 0.0f;
+ mMatrix[9] = 0.0f;
+ mMatrix[10] = scale.z;
+ mMatrix[11] = 0.0f;
}
else
{
MATH_INCREASE_COUNTER(PerformanceMonitor::MATRIX_MULTIPLYS);
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,27); // 27 = 9+18
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 27); // 27 = 9+18
const float xx = rotation.mVector.x * rotation.mVector.x;
const float yy = rotation.mVector.y * rotation.mVector.y;
const float yz = rotation.mVector.y * rotation.mVector.z;
mMatrix[0] = (scale.x * (1.0f - 2.0f * (yy + zz)));
- mMatrix[1] = (scale.x * ( 2.0f * (xy + wz)));
- mMatrix[2] = (scale.x * ( 2.0f * (xz - wy)));
+ mMatrix[1] = (scale.x * (2.0f * (xy + wz)));
+ mMatrix[2] = (scale.x * (2.0f * (xz - wy)));
mMatrix[3] = 0.0f;
- mMatrix[4] = (scale.y * ( 2.0f * (xy - wz)));
+ mMatrix[4] = (scale.y * (2.0f * (xy - wz)));
mMatrix[5] = (scale.y * (1.0f - 2.0f * (xx + zz)));
- mMatrix[6] = (scale.y * ( 2.0f * (yz + wx)));
+ mMatrix[6] = (scale.y * (2.0f * (yz + wx)));
mMatrix[7] = 0.0f;
- mMatrix[8] = (scale.z * ( 2.0f * (xz + wy)));
- mMatrix[9] = (scale.z * ( 2.0f * (yz - wx)));
- mMatrix[10]= (scale.z * (1.0f - 2.0f * (xx + yy)));
- mMatrix[11]= 0.0f;
+ mMatrix[8] = (scale.z * (2.0f * (xz + wy)));
+ mMatrix[9] = (scale.z * (2.0f * (yz - wx)));
+ mMatrix[10] = (scale.z * (1.0f - 2.0f * (xx + yy)));
+ mMatrix[11] = 0.0f;
}
// apply translation
mMatrix[12] = translation.x;
void Matrix::SetInverseTransformComponents(const Vector3& scale,
const Quaternion& rotation,
- const Vector3& translation )
+ const Vector3& translation)
{
- Vector3 inverseTranslation = -translation;
- Vector3 inverseScale( 1.0f/scale.x, 1.0f/scale.y, 1.0f/scale.z);
+ Vector3 inverseTranslation = -translation;
+ Vector3 inverseScale(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z);
Quaternion inverseRotation(rotation);
- bool isRotated = ! inverseRotation.IsIdentity();
+ bool isRotated = !inverseRotation.IsIdentity();
// Order of application is translation, rotation, scale.
// Ensure translation is relative to scale & rotation:
- if( isRotated )
+ if(isRotated)
{
inverseRotation.Invert();
inverseTranslation = inverseRotation.Rotate(inverseTranslation);
inverseTranslation *= inverseScale;
- if( isRotated )
+ if(isRotated)
{
MATH_INCREASE_COUNTER(PerformanceMonitor::MATRIX_MULTIPLYS);
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,27); // 27 = 9+18
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 27); // 27 = 9+18
const float xx = inverseRotation.mVector.x * inverseRotation.mVector.x;
const float yy = inverseRotation.mVector.y * inverseRotation.mVector.y;
mMatrix[6] = (inverseScale.z * (2.0f * (yz + wx)));
mMatrix[7] = 0.0f;
- mMatrix[8] = (inverseScale.x * (2.0f * (xz + wy)));
- mMatrix[9] = (inverseScale.y * (2.0f * (yz - wx)));
- mMatrix[10]= (inverseScale.z * (1.0f - 2.0f * (xx + yy)));
- mMatrix[11]= 0.0f;
+ mMatrix[8] = (inverseScale.x * (2.0f * (xz + wy)));
+ mMatrix[9] = (inverseScale.y * (2.0f * (yz - wx)));
+ mMatrix[10] = (inverseScale.z * (1.0f - 2.0f * (xx + yy)));
+ mMatrix[11] = 0.0f;
}
else
{
mMatrix[6] = 0.0f;
mMatrix[7] = 0.0f;
- mMatrix[8] = 0.0f;
- mMatrix[9] = 0.0f;
- mMatrix[10]= inverseScale.z;
- mMatrix[11]= 0.0f;
+ mMatrix[8] = 0.0f;
+ mMatrix[9] = 0.0f;
+ mMatrix[10] = inverseScale.z;
+ mMatrix[11] = 0.0f;
}
// apply translation
mMatrix[15] = 1.0f;
}
-void Matrix::SetInverseTransformComponents(const Vector3& xAxis,
- const Vector3& yAxis,
- const Vector3& zAxis,
- const Vector3& translation )
+void Matrix::SetInverseTransformComponents(const Vector3& xAxis,
+ const Vector3& yAxis,
+ const Vector3& zAxis,
+ const Vector3& translation)
{
// x, y, z axis parameters represent a orthonormal basis with no scaling, i.e. a rotation matrix.
// Invert rotation by transposing in place
// Order of application is translation, rotation
- mMatrix[0] = xAxis.x;
- mMatrix[1] = yAxis.x;
- mMatrix[2] = zAxis.x;
- mMatrix[3] = 0.0f;
+ mMatrix[0] = xAxis.x;
+ mMatrix[1] = yAxis.x;
+ mMatrix[2] = zAxis.x;
+ mMatrix[3] = 0.0f;
- mMatrix[4] = xAxis.y;
- mMatrix[5] = yAxis.y;
- mMatrix[6] = zAxis.y;
- mMatrix[7] = 0.0f;
+ mMatrix[4] = xAxis.y;
+ mMatrix[5] = yAxis.y;
+ mMatrix[6] = zAxis.y;
+ mMatrix[7] = 0.0f;
mMatrix[8] = xAxis.z;
mMatrix[9] = yAxis.z;
// Ensure translation is relative to scale & rotation:
- Vector4 inverseTranslation( -translation.x, -translation.y, -translation.z, 1.0f);
- inverseTranslation = *this * inverseTranslation; // Rotate inverse translation
+ Vector4 inverseTranslation(-translation.x, -translation.y, -translation.z, 1.0f);
+ inverseTranslation = *this * inverseTranslation; // Rotate inverse translation
inverseTranslation.w = 1.0f;
SetTranslation(inverseTranslation);
}
-
-void Matrix::GetTransformComponents(Vector3& position,
- Quaternion& rotation,
- Vector3& scale) const
+void Matrix::GetTransformComponents(Vector3& position,
+ Quaternion& rotation,
+ Vector3& scale) const
{
position = GetTranslation3();
Vector3 theScale(GetXAxis().Length(), GetYAxis().Length(), GetZAxis().Length());
scale = theScale;
- if( ! ( fabs(theScale.x - Vector3::ONE.x) < ROTATION_EPSILON &&
- fabs(theScale.y - Vector3::ONE.y) < ROTATION_EPSILON &&
- fabs(theScale.z - Vector3::ONE.z) < ROTATION_EPSILON ) )
+ if(!(fabs(theScale.x - Vector3::ONE.x) < ROTATION_EPSILON &&
+ fabs(theScale.y - Vector3::ONE.y) < ROTATION_EPSILON &&
+ fabs(theScale.z - Vector3::ONE.z) < ROTATION_EPSILON))
{
MATH_INCREASE_COUNTER(PerformanceMonitor::MATRIX_MULTIPLYS);
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,9);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 9);
// Non-identity scale is embedded into rotation matrix. Remove it first:
- Matrix m(*this);
- Vector3 inverseScale(1.0f/theScale.x, 1.0f/theScale.y, 1.0f/theScale.z);
+ Matrix m(*this);
+ Vector3 inverseScale(1.0f / theScale.x, 1.0f / theScale.y, 1.0f / theScale.z);
m.mMatrix[0] *= inverseScale.x;
m.mMatrix[1] *= inverseScale.x;
m.mMatrix[2] *= inverseScale.x;
Quaternion theRotation(m);
// If the imaginary components are close to zero, then use null quaternion instead.
- if( fabs(theRotation.mVector.x) < ROTATION_EPSILON &&
- fabs(theRotation.mVector.y) < ROTATION_EPSILON &&
- fabs(theRotation.mVector.z) < ROTATION_EPSILON )
+ if(fabs(theRotation.mVector.x) < ROTATION_EPSILON &&
+ fabs(theRotation.mVector.y) < ROTATION_EPSILON &&
+ fabs(theRotation.mVector.z) < ROTATION_EPSILON)
{
theRotation = Quaternion();
}
Quaternion theRotation(*this);
// If the imaginary components are close to zero, then use null quaternion instead.
- if( fabs(theRotation.mVector.x) < ROTATION_EPSILON &&
- fabs(theRotation.mVector.y) < ROTATION_EPSILON &&
- fabs(theRotation.mVector.z) < ROTATION_EPSILON )
+ if(fabs(theRotation.mVector.x) < ROTATION_EPSILON &&
+ fabs(theRotation.mVector.y) < ROTATION_EPSILON &&
+ fabs(theRotation.mVector.z) < ROTATION_EPSILON)
{
theRotation = Quaternion();
}
}
}
-
-
-std::ostream& operator<< (std::ostream& o, const Matrix& matrix)
+std::ostream& operator<<(std::ostream& o, const Matrix& matrix)
{
- return o << "[ " << matrix.mMatrix[0] << ", " << matrix.mMatrix[1] << ", " << matrix.mMatrix[2] << ", " << matrix.mMatrix[3] << ", "
- << matrix.mMatrix[4] << ", " << matrix.mMatrix[5] << ", " << matrix.mMatrix[6] << ", " << matrix.mMatrix[7] << ", "
- << matrix.mMatrix[8] << ", " << matrix.mMatrix[9] << ", " << matrix.mMatrix[10] << ", " << matrix.mMatrix[11] << ", "
- << matrix.mMatrix[12] << ", " << matrix.mMatrix[13] << ", " << matrix.mMatrix[14] << ", " << matrix.mMatrix[15] << " ]";
+ return o << "[ " << matrix.mMatrix[0] << ", " << matrix.mMatrix[1] << ", " << matrix.mMatrix[2] << ", " << matrix.mMatrix[3] << ", "
+ << matrix.mMatrix[4] << ", " << matrix.mMatrix[5] << ", " << matrix.mMatrix[6] << ", " << matrix.mMatrix[7] << ", "
+ << matrix.mMatrix[8] << ", " << matrix.mMatrix[9] << ", " << matrix.mMatrix[10] << ", " << matrix.mMatrix[11] << ", "
+ << matrix.mMatrix[12] << ", " << matrix.mMatrix[13] << ", " << matrix.mMatrix[14] << ", " << matrix.mMatrix[15] << " ]";
}
} // namespace Dali
class DALI_CORE_API Matrix
{
public:
-
- friend DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Matrix& matrix);
+ friend DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Matrix& matrix);
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param[in] initialize True for initialization by zero or otherwise
*/
- explicit Matrix( bool initialize );
+ explicit Matrix(bool initialize);
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param rotation Rotation as quaternion
*/
- explicit Matrix( const Quaternion& rotation );
+ explicit Matrix(const Quaternion& rotation);
/**
* @brief Copy constructor.
* @SINCE_1_0.0
* @param[in] matrix A reference to the copied matrix
*/
- Matrix( const Matrix& matrix );
+ Matrix(const Matrix& matrix);
/**
* @brief Assignment operator.
* @param[in] matrix A reference to the copied matrix
* @return A reference to this
*/
- Matrix& operator=( const Matrix& matrix );
+ Matrix& operator=(const Matrix& matrix);
/**
* @brief Move constructor.
* @SINCE_1_9.21
* @param[in] matrix A reference to the moved matrix
*/
- Matrix( Matrix&& matrix );
+ Matrix(Matrix&& matrix);
/**
* @brief Move assignment operator.
* @param[in] matrix A reference to the moved matrix
* @return A reference to this
*/
- Matrix& operator=( Matrix&& matrix );
+ Matrix& operator=(Matrix&& matrix);
/**
* @brief The identity matrix.
* @SINCE_1_0.0
* @param[in] scale Scale to set on top of identity matrix
*/
- void SetIdentityAndScale( const Vector3& scale );
+ void SetIdentityAndScale(const Vector3& scale);
/**
* @brief Inverts a transform Matrix.
* @return The translation
* @note inlined for performance reasons (generates less code than a function call)
*/
- const Vector4& GetTranslation() const { return reinterpret_cast<const Vector4&>(mMatrix[12]); }
+ const Vector4& GetTranslation() const
+ {
+ return reinterpret_cast<const Vector4&>(mMatrix[12]);
+ }
/**
* @brief Gets the x,y and z components of the translation as a Vector3.
* @return The translation
* @note inlined for performance reasons (generates less code than a function call)
*/
- const Vector3& GetTranslation3() const { return reinterpret_cast<const Vector3&>(mMatrix[12]); }
+ const Vector3& GetTranslation3() const
+ {
+ return reinterpret_cast<const Vector3&>(mMatrix[12]);
+ }
/**
* @brief Sets the translation.
* @return The matrix contents as an array of 16 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- const float* AsFloat() const {return mMatrix;}
+ const float* AsFloat() const
+ {
+ return mMatrix;
+ }
/**
* @brief Returns the contents of the matrix as an array of 16 floats.
* @return The matrix contents as an array of 16 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- float* AsFloat() {return mMatrix;}
+ float* AsFloat()
+ {
+ return mMatrix;
+ }
/**
* @brief Function to multiply two matrices and store the result onto third.
* @param[in] lhs Matrix, this can be same matrix as result
* @param[in] rhs Matrix, this cannot be same matrix as result
*/
- static void Multiply( Matrix& result, const Matrix& lhs, const Matrix& rhs );
+ static void Multiply(Matrix& result, const Matrix& lhs, const Matrix& rhs);
/**
* @brief Function to multiply a matrix and quaternion and store the result onto third.
* @param[in] lhs Matrix, this can be same matrix as result
* @param[in] rhs Quaternion
*/
- static void Multiply( Matrix& result, const Matrix& lhs, const Quaternion& rhs );
+ static void Multiply(Matrix& result, const Matrix& lhs, const Quaternion& rhs);
/**
* @brief The multiplication operator.
* @param[in] rhs The Matrix to compare this to
* @return true if the matrices are equal
*/
- bool operator==(const Matrix & rhs) const;
+ bool operator==(const Matrix& rhs) const;
/**
* @brief The inequality operator.
* @param[in] rhs The Matrix to compare this to
* @return true if the matrices are not equal.
*/
- bool operator!=(const Matrix & rhs) const;
+ bool operator!=(const Matrix& rhs) const;
/**
* @brief Sets this matrix to contain the position, scale and rotation components.
* @param[in] rotation Rotation to apply
* @param[in] translation Translation to apply
*/
- void SetTransformComponents(const Vector3& scale,
+ void SetTransformComponents(const Vector3& scale,
const Quaternion& rotation,
- const Vector3& translation );
+ const Vector3& translation);
/**
* @brief Sets this matrix to contain the inverse of the position, scale and rotation components.
*/
void SetInverseTransformComponents(const Vector3& scale,
const Quaternion& rotation,
- const Vector3& translation );
-
+ const Vector3& translation);
/**
* @brief Sets this matrix to contain the inverse of the orthonormal basis and position components.
* @param[in] zAxis The Z axis of the basis
* @param[in] translation Translation to apply
*/
- void SetInverseTransformComponents(const Vector3& xAxis,
- const Vector3& yAxis,
- const Vector3& zAxis,
- const Vector3& translation );
+ void SetInverseTransformComponents(const Vector3& xAxis,
+ const Vector3& yAxis,
+ const Vector3& zAxis,
+ const Vector3& translation);
/**
* @brief Gets the position, scale and rotation components from the given transform matrix.
* @param[out] scale Scale to set - only valid if the transform matrix has not been skewed or sheared
* @pre This matrix must not contain skews or shears.
*/
- void GetTransformComponents(Vector3& position,
+ void GetTransformComponents(Vector3& position,
Quaternion& rotation,
- Vector3& scale) const;
+ Vector3& scale) const;
private:
-
float mMatrix[16]; ///< The elements of the matrix
};
* @param[in] matrix The matrix to print
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Matrix& matrix);
+DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Matrix& matrix);
// Allow Matrix to be treated as a POD type
-template <> struct TypeTraits< Matrix > : public BasicTypes< Matrix > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Matrix> : public BasicTypes<Matrix>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
namespace
{
-const uint32_t NUM_BYTES_IN_ROW = 3*sizeof(float);
-const uint32_t NUM_BYTES_IN_MATRIX = 9*sizeof(float);
-}
+const uint32_t NUM_BYTES_IN_ROW = 3 * sizeof(float);
+const uint32_t NUM_BYTES_IN_MATRIX = 9 * sizeof(float);
+} // namespace
namespace Dali
{
-
-const Matrix3 Matrix3::IDENTITY(1.0f, 0.0f, 0.0f,
- 0.0f, 1.0f, 0.0f,
- 0.0f, 0.0f, 1.0f);
+const Matrix3 Matrix3::IDENTITY(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
Matrix3::Matrix3()
{
Matrix3::Matrix3(const Matrix3& m)
{
- memcpy( mElements, m.mElements, NUM_BYTES_IN_MATRIX );
+ memcpy(mElements, m.mElements, NUM_BYTES_IN_MATRIX);
}
Matrix3::Matrix3(const Matrix& matrix)
{
const float* m4 = matrix.AsFloat();
- memcpy(&mElements[S00], m4, NUM_BYTES_IN_ROW);
- memcpy(&mElements[S10], m4+4, NUM_BYTES_IN_ROW);
- memcpy(&mElements[S20], m4+8, NUM_BYTES_IN_ROW);
+ memcpy(&mElements[S00], m4, NUM_BYTES_IN_ROW);
+ memcpy(&mElements[S10], m4 + 4, NUM_BYTES_IN_ROW);
+ memcpy(&mElements[S20], m4 + 8, NUM_BYTES_IN_ROW);
}
Matrix3::Matrix3(float s00, float s01, float s02, float s10, float s11, float s12, float s20, float s21, float s22)
mElements[S22] = s22;
}
-
void Matrix3::SetIdentity()
{
memset(mElements, 0, NUM_BYTES_IN_MATRIX);
- mElements[S00]=1.0f;
- mElements[S11]=1.0f;
- mElements[S22]=1.0f;
+ mElements[S00] = 1.0f;
+ mElements[S11] = 1.0f;
+ mElements[S22] = 1.0f;
}
-Matrix3::Matrix3( Matrix3&& matrix )
+Matrix3::Matrix3(Matrix3&& matrix)
{
- memcpy( mElements, matrix.mElements, NUM_BYTES_IN_MATRIX );
+ memcpy(mElements, matrix.mElements, NUM_BYTES_IN_MATRIX);
}
-Matrix3& Matrix3::operator=( Matrix3&& matrix )
+Matrix3& Matrix3::operator=(Matrix3&& matrix)
{
- if( this != &matrix )
+ if(this != &matrix)
{
- memcpy( AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX );
+ memcpy(AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX);
}
return *this;
}
-Matrix3& Matrix3::operator=( const Matrix3& matrix )
+Matrix3& Matrix3::operator=(const Matrix3& matrix)
{
// no point copying if self assigning
- if( this != &matrix )
+ if(this != &matrix)
{
- memcpy( AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX );
+ memcpy(AsFloat(), matrix.AsFloat(), NUM_BYTES_IN_MATRIX);
}
return *this;
}
-Matrix3& Matrix3::operator=( const Matrix& matrix )
+Matrix3& Matrix3::operator=(const Matrix& matrix)
{
const float* m4 = matrix.AsFloat();
- memcpy(&mElements[S00], m4, NUM_BYTES_IN_ROW);
- memcpy(&mElements[S10], m4+4, NUM_BYTES_IN_ROW);
- memcpy(&mElements[S20], m4+8, NUM_BYTES_IN_ROW);
+ memcpy(&mElements[S00], m4, NUM_BYTES_IN_ROW);
+ memcpy(&mElements[S10], m4 + 4, NUM_BYTES_IN_ROW);
+ memcpy(&mElements[S20], m4 + 8, NUM_BYTES_IN_ROW);
return *this;
}
float det = mElements[S00] * cof[S00] + mElements[S01] * cof[S10] + mElements[S02] * cof[S20];
// In the case where the determinant is exactly zero, the matrix is non-invertible
- if( ! EqualsZero( det ) )
+ if(!EqualsZero(det))
{
det = 1.0f / det;
- for( int32_t i = 0; i < 9; i++ )
+ for(int32_t i = 0; i < 9; i++)
{
mElements[i] = cof[i] * det;
}
bool Matrix3::Transpose()
{
float tmp;
- tmp = mElements[S01]; mElements[S01] = mElements[S10]; mElements[S10]=tmp;
- tmp = mElements[S02]; mElements[S02] = mElements[S20]; mElements[S20]=tmp;
- tmp = mElements[S21]; mElements[S21] = mElements[S12]; mElements[S12]=tmp;
+ tmp = mElements[S01];
+ mElements[S01] = mElements[S10];
+ mElements[S10] = tmp;
+ tmp = mElements[S02];
+ mElements[S02] = mElements[S20];
+ mElements[S20] = tmp;
+ tmp = mElements[S21];
+ mElements[S21] = mElements[S12];
+ mElements[S12] = tmp;
return true;
}
float det = mElements[S00] * cof[S00] + mElements[S01] * cof[S10] + mElements[S02] * cof[S20];
// In the case where the determinant is exactly zero, the matrix is non-invertible
- if( ! EqualsZero( det ) )
+ if(!EqualsZero(det))
{
// Use average rather than determinant to remove rounding to zero errors in further multiplication
- float sum=0;
- for(uint32_t i=0;i<9;i++)
+ float sum = 0;
+ for(uint32_t i = 0; i < 9; i++)
{
- sum+=fabsf(cof[i]);
+ sum += fabsf(cof[i]);
}
- float scale = 9.0f/sum; // Inverse of the average values
- if (det < 0)
+ float scale = 9.0f / sum; // Inverse of the average values
+ if(det < 0)
{
// Ensure the signs of the inverse are correct
scale = -scale;
float Matrix3::Magnitude() const
{
- float avg=0;
- for(uint32_t i=0;i<9;i++)
+ float avg = 0;
+ for(uint32_t i = 0; i < 9; i++)
{
- avg+=fabsf(mElements[i]);
+ avg += fabsf(mElements[i]);
}
- return avg/3.0f;
+ return avg / 3.0f;
}
-
-void Matrix3::Multiply( Matrix3& result, const Matrix3& lhs, const Matrix3& rhs )
+void Matrix3::Multiply(Matrix3& result, const Matrix3& lhs, const Matrix3& rhs)
{
- float* temp = result.AsFloat();
- const float* rhsPtr = rhs.AsFloat();
+ float* temp = result.AsFloat();
+ const float* rhsPtr = rhs.AsFloat();
const float* lhsPtr = lhs.AsFloat();
- for( int32_t i=0; i < 3; i++ )
+ for(int32_t i = 0; i < 3; i++)
{
- int32_t loc = i * 3;
+ int32_t loc = i * 3;
int32_t loc1 = loc + 1;
int32_t loc2 = loc + 2;
float value0 = lhsPtr[loc];
float value1 = lhsPtr[loc1];
float value2 = lhsPtr[loc2];
- temp[loc] = (value0 * rhsPtr[0]) +
- (value1 * rhsPtr[3]) +
- (value2 * rhsPtr[6]);
+ temp[loc] = (value0 * rhsPtr[0]) +
+ (value1 * rhsPtr[3]) +
+ (value2 * rhsPtr[6]);
temp[loc1] = (value0 * rhsPtr[1]) +
(value1 * rhsPtr[4]) +
}
}
-bool Matrix3::operator==(const Matrix3 & rhs) const
+bool Matrix3::operator==(const Matrix3& rhs) const
{
return (
- Equals( mElements[0], rhs.mElements[0]) &&
- Equals( mElements[1], rhs.mElements[1]) &&
- Equals( mElements[2], rhs.mElements[2]) &&
- Equals( mElements[3], rhs.mElements[3]) &&
- Equals( mElements[4], rhs.mElements[4]) &&
- Equals( mElements[5], rhs.mElements[5]) &&
- Equals( mElements[6], rhs.mElements[6]) &&
- Equals( mElements[7], rhs.mElements[7]) &&
- Equals( mElements[8], rhs.mElements[8]));
+ Equals(mElements[0], rhs.mElements[0]) &&
+ Equals(mElements[1], rhs.mElements[1]) &&
+ Equals(mElements[2], rhs.mElements[2]) &&
+ Equals(mElements[3], rhs.mElements[3]) &&
+ Equals(mElements[4], rhs.mElements[4]) &&
+ Equals(mElements[5], rhs.mElements[5]) &&
+ Equals(mElements[6], rhs.mElements[6]) &&
+ Equals(mElements[7], rhs.mElements[7]) &&
+ Equals(mElements[8], rhs.mElements[8]));
}
bool Matrix3::operator!=(const Matrix3& rhs) const
return !(*this == rhs);
}
-std::ostream& operator<< (std::ostream& o, const Matrix3& matrix)
+std::ostream& operator<<(std::ostream& o, const Matrix3& matrix)
{
return o << "[ " << matrix.mElements[0] << ", " << matrix.mElements[1] << ", " << matrix.mElements[2] << ", "
- << matrix.mElements[3] << ", " << matrix.mElements[4] << ", " << matrix.mElements[5] << ", "
- << matrix.mElements[6] << ", " << matrix.mElements[7] << ", " << matrix.mElements[8] << " ]";
+ << matrix.mElements[3] << ", " << matrix.mElements[4] << ", " << matrix.mElements[5] << ", "
+ << matrix.mElements[6] << ", " << matrix.mElements[7] << ", " << matrix.mElements[8] << " ]";
}
} // namespace Dali
*/
// INTERNAL INCLUDES
-#include <dali/public-api/math/vector3.h>
-#include <dali/public-api/math/matrix.h>
#include <dali/public-api/common/type-traits.h>
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/vector3.h>
namespace Dali
{
class DALI_CORE_API Matrix3
{
public:
-
- friend DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Matrix3& matrix);
+ friend DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Matrix3& matrix);
/**
* @brief The identity matrix.
* @SINCE_1_9.21
* @param[in] matrix A reference to the moved matrix
*/
- Matrix3( Matrix3&& matrix );
+ Matrix3(Matrix3&& matrix);
/**
* @brief Move assignment operator.
* @param[in] matrix A reference to the moved matrix
* @return A reference to this
*/
- Matrix3& operator=( Matrix3&& matrix );
+ Matrix3& operator=(Matrix3&& matrix);
/**
* @brief Assignment Operator.
* @param[in] matrix From which to copy values
* @return Reference to this object
*/
- Matrix3& operator=( const Matrix3& matrix );
+ Matrix3& operator=(const Matrix3& matrix);
/**
* @brief Assignment Operator.
* @param[in] matrix A reference to the copied matrix
* @return A reference to this
*/
- Matrix3& operator=( const Matrix& matrix );
+ Matrix3& operator=(const Matrix& matrix);
/**
* @brief The equality operator.
* @param[in] rhs The Matrix to compare this to
* @return True if the matrices are equal
*/
- bool operator==(const Matrix3 & rhs) const;
+ bool operator==(const Matrix3& rhs) const;
/**
* @brief The inequality operator.
* @param[in] rhs The Matrix to compare this to
* @return true if the matrices are equal
*/
- bool operator!=(const Matrix3 & rhs) const;
+ bool operator!=(const Matrix3& rhs) const;
/**
* @brief Destructor.
* @SINCE_1_0.0
* @return The matrix contents as an array of 9 floats
*/
- const float* AsFloat() const {return &mElements[0];}
+ const float* AsFloat() const
+ {
+ return &mElements[0];
+ }
/**
* @brief Returns the contents of the matrix as an array of 9 floats.
* @SINCE_1_0.0
* @return The matrix contents as an array of 9 floats
*/
- float* AsFloat() {return &mElements[0];}
+ float* AsFloat()
+ {
+ return &mElements[0];
+ }
/**
* @brief Inverts the matrix.
* @param[in] lhs Matrix, this can be same matrix as result
* @param[in] rhs Matrix, this cannot be same matrix as result
*/
- static void Multiply( Matrix3& result, const Matrix3& lhs, const Matrix3& rhs );
+ static void Multiply(Matrix3& result, const Matrix3& lhs, const Matrix3& rhs);
private:
-
float mElements[9]; ///< The elements of the matrix
};
* @param[in] matrix The matrix to print
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Matrix3& matrix);
+DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Matrix3& matrix);
// Allow Matrix3 to be treated as a POD type
-template <> struct TypeTraits< Matrix3 > : public BasicTypes< Matrix3 > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Matrix3> : public BasicTypes<Matrix3>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <ostream>
// INTERNAL INCLUDES
+#include <dali/internal/render/common/performance-monitor.h>
#include <dali/public-api/common/constants.h>
#include <dali/public-api/math/degree.h>
+#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/math/matrix.h>
#include <dali/public-api/math/radian.h>
-#include <dali/public-api/math/math-utils.h>
-#include <dali/internal/render/common/performance-monitor.h>
namespace Dali
{
const Quaternion Quaternion::IDENTITY;
-
/**
* Default Constructor
*/
Quaternion::Quaternion()
-: mVector( 0.0f, 0.0f, 0.0f, 1.0f )
+: mVector(0.0f, 0.0f, 0.0f, 1.0f)
{
}
-Quaternion::Quaternion( float cosThetaBy2, float iBySineTheta, float jBySineTheta, float kBySineTheta )
-: mVector( iBySineTheta, jBySineTheta, kBySineTheta, cosThetaBy2 )
+Quaternion::Quaternion(float cosThetaBy2, float iBySineTheta, float jBySineTheta, float kBySineTheta)
+: mVector(iBySineTheta, jBySineTheta, kBySineTheta, cosThetaBy2)
{
}
-Quaternion::Quaternion( const Vector4& vector )
-: mVector( vector )
+Quaternion::Quaternion(const Vector4& vector)
+: mVector(vector)
{
}
-Quaternion::Quaternion( Radian angle, const Vector3& axis )
+Quaternion::Quaternion(Radian angle, const Vector3& axis)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,4);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 4);
Vector3 tmpAxis = axis;
tmpAxis.Normalize();
- const float halfAngle = angle.radian * 0.5f;
+ const float halfAngle = angle.radian * 0.5f;
const float sinThetaByTwo = sinf(halfAngle);
const float cosThetaByTwo = cosf(halfAngle);
- mVector.x = tmpAxis.x * sinThetaByTwo;
- mVector.y = tmpAxis.y * sinThetaByTwo;
- mVector.z = tmpAxis.z * sinThetaByTwo;
- mVector.w = cosThetaByTwo;
+ mVector.x = tmpAxis.x * sinThetaByTwo;
+ mVector.y = tmpAxis.y * sinThetaByTwo;
+ mVector.z = tmpAxis.z * sinThetaByTwo;
+ mVector.w = cosThetaByTwo;
}
-Quaternion::Quaternion( Radian pitch, Radian yaw, Radian roll )
+Quaternion::Quaternion(Radian pitch, Radian yaw, Radian roll)
{
- SetEuler( pitch, yaw, roll );
+ SetEuler(pitch, yaw, roll);
}
-Quaternion::Quaternion( const Matrix& matrix )
+Quaternion::Quaternion(const Matrix& matrix)
{
- Vector3 xAxis( matrix.GetXAxis() );
- Vector3 yAxis( matrix.GetYAxis() );
- Vector3 zAxis( matrix.GetZAxis() );
+ Vector3 xAxis(matrix.GetXAxis());
+ Vector3 yAxis(matrix.GetYAxis());
+ Vector3 zAxis(matrix.GetZAxis());
- SetFromAxes( xAxis, yAxis, zAxis );
+ SetFromAxes(xAxis, yAxis, zAxis);
}
-Quaternion::Quaternion( const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis )
+Quaternion::Quaternion(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis)
{
- SetFromAxes( xAxis, yAxis, zAxis );
+ SetFromAxes(xAxis, yAxis, zAxis);
}
-Quaternion::Quaternion( const Vector3& v0, const Vector3& v1 )
+Quaternion::Quaternion(const Vector3& v0, const Vector3& v1)
{
float dot = v0.Dot(v1);
- if( dot > 1.0f - Math::MACHINE_EPSILON_1 )
+ if(dot > 1.0f - Math::MACHINE_EPSILON_1)
{
//Identity quaternion
mVector.x = mVector.y = mVector.z = 0.0f;
- mVector.w = 1.0f;
+ mVector.w = 1.0f;
}
- else if( dot < -1.0f + Math::MACHINE_EPSILON_1)
+ else if(dot < -1.0f + Math::MACHINE_EPSILON_1)
{
//180 degree rotation across the Z axis
mVector.x = mVector.y = mVector.w = 0.0f;
- mVector.z = 1.0f;
+ mVector.z = 1.0f;
}
else
{
{
// start from w as its unlikely that any real rotation has w == 1
// Uses a relaxed epsilon, as composition of rotation introduces error
- return ( ( fabsf( mVector.w - 1.0f ) < Math::MACHINE_EPSILON_10 )&&
- ( fabsf( mVector.x ) < Math::MACHINE_EPSILON_10 )&&
- ( fabsf( mVector.y ) < Math::MACHINE_EPSILON_10 )&&
- ( fabsf( mVector.z ) < Math::MACHINE_EPSILON_10 ) );
+ return ((fabsf(mVector.w - 1.0f) < Math::MACHINE_EPSILON_10) &&
+ (fabsf(mVector.x) < Math::MACHINE_EPSILON_10) &&
+ (fabsf(mVector.y) < Math::MACHINE_EPSILON_10) &&
+ (fabsf(mVector.z) < Math::MACHINE_EPSILON_10));
}
bool Quaternion::ToAxisAngle(Vector3& axis, Radian& angle) const
{
- angle = acosf(mVector.w);
+ angle = acosf(mVector.w);
bool converted = false;
// pre-compute to save time
- const float sine = sinf( angle.radian );
+ const float sine = sinf(angle.radian);
// If sine(angle) is zero, conversion is not possible
- if ( ! EqualsZero( sine ) )
+ if(!EqualsZero(sine))
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
float sinf_theta_inv = 1.0f / sine;
- axis.x = mVector.x*sinf_theta_inv;
- axis.y = mVector.y*sinf_theta_inv;
- axis.z = mVector.z*sinf_theta_inv;
+ axis.x = mVector.x * sinf_theta_inv;
+ axis.y = mVector.y * sinf_theta_inv;
+ axis.z = mVector.z * sinf_theta_inv;
angle.radian *= 2.0f;
converted = true;
}
return mVector;
}
-void Quaternion::SetEuler( Radian pitch, Radian yaw, Radian roll )
+void Quaternion::SetEuler(Radian pitch, Radian yaw, Radian roll)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,19);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 19);
const float halfX = 0.5f * pitch.radian;
const float halfY = 0.5f * yaw.radian;
Vector4 Quaternion::EulerAngles() const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,13);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 13);
- float sqw = mVector.w*mVector.w;
- float sqx = mVector.x*mVector.x;
- float sqy = mVector.y*mVector.y;
- float sqz = mVector.z*mVector.z;
+ float sqw = mVector.w * mVector.w;
+ float sqx = mVector.x * mVector.x;
+ float sqy = mVector.y * mVector.y;
+ float sqz = mVector.z * mVector.z;
Vector4 euler;
- euler.x = atan2f(2.0f * (mVector.y*mVector.z + mVector.x*mVector.w), -sqx - sqy + sqz + sqw);
- euler.y = asinf(-2.0f * (mVector.x*mVector.z - mVector.y*mVector.w));
- euler.z = atan2f(2.0f * (mVector.x*mVector.y + mVector.z*mVector.w), sqx - sqy - sqz + sqw);
+ euler.x = atan2f(2.0f * (mVector.y * mVector.z + mVector.x * mVector.w), -sqx - sqy + sqz + sqw);
+ euler.y = asinf(-2.0f * (mVector.x * mVector.z - mVector.y * mVector.w));
+ euler.z = atan2f(2.0f * (mVector.x * mVector.y + mVector.z * mVector.w), sqx - sqy - sqz + sqw);
return euler;
}
-const Quaternion Quaternion::operator+( const Quaternion& other ) const
+const Quaternion Quaternion::operator+(const Quaternion& other) const
{
return Quaternion(mVector + other.mVector);
}
-const Quaternion Quaternion::operator-( const Quaternion& other ) const
+const Quaternion Quaternion::operator-(const Quaternion& other) const
{
return Quaternion(mVector - other.mVector);
}
-const Quaternion Quaternion::operator*( const Quaternion& other ) const
+const Quaternion Quaternion::operator*(const Quaternion& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,12);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 12);
return Quaternion(mVector.w * other.mVector.w - mVector.Dot(other.mVector),
mVector.y * other.mVector.z - mVector.z * other.mVector.y + mVector.w * other.mVector.x + mVector.x * other.mVector.w,
mVector.x * other.mVector.y - mVector.y * other.mVector.x + mVector.w * other.mVector.z + mVector.z * other.mVector.w);
}
-Vector3 Quaternion::operator*( const Vector3& other ) const
+Vector3 Quaternion::operator*(const Vector3& other) const
{
Vector3 qvec(mVector.x, mVector.y, mVector.z);
- Vector3 uv = qvec.Cross( other );
+ Vector3 uv = qvec.Cross(other);
Vector3 uuv = qvec.Cross(uv);
uv *= (2.0f * mVector.w);
uuv *= 2.0f;
return other + uv + uuv;
}
-const Quaternion Quaternion::operator/( const Quaternion& q ) const
+const Quaternion Quaternion::operator/(const Quaternion& q) const
{
Quaternion p(q);
p.Invert();
return *this * p;
}
-const Quaternion Quaternion::operator*( float scale ) const
+const Quaternion Quaternion::operator*(float scale) const
{
- return Quaternion(mVector*scale);
+ return Quaternion(mVector * scale);
}
-const Quaternion Quaternion::operator/( float scale ) const
+const Quaternion Quaternion::operator/(float scale) const
{
- return Quaternion(mVector/scale);
+ return Quaternion(mVector / scale);
}
Quaternion Quaternion::operator-() const
return Quaternion(-mVector.w, -mVector.x, -mVector.y, -mVector.z);
}
-const Quaternion& Quaternion::operator+=( const Quaternion& q )
+const Quaternion& Quaternion::operator+=(const Quaternion& q)
{
- mVector += q.mVector; return *this;
+ mVector += q.mVector;
+ return *this;
}
-const Quaternion& Quaternion::operator-=( const Quaternion& q )
+const Quaternion& Quaternion::operator-=(const Quaternion& q)
{
- mVector -= q.mVector; return *this;
+ mVector -= q.mVector;
+ return *this;
}
-const Quaternion& Quaternion::operator*=( const Quaternion& q )
+const Quaternion& Quaternion::operator*=(const Quaternion& q)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,12);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 12);
float x = mVector.x, y = mVector.y, z = mVector.z, w = mVector.w;
mVector.w = mVector.w * q.mVector.w - mVector.Dot(q.mVector);
- mVector.x = y*q.mVector.z - z*q.mVector.y + w*q.mVector.x + x*q.mVector.w;
- mVector.y = z*q.mVector.x - x*q.mVector.z + w*q.mVector.y + y*q.mVector.w;
- mVector.z = x*q.mVector.y - y*q.mVector.x + w*q.mVector.z + z*q.mVector.w;
+ mVector.x = y * q.mVector.z - z * q.mVector.y + w * q.mVector.x + x * q.mVector.w;
+ mVector.y = z * q.mVector.x - x * q.mVector.z + w * q.mVector.y + y * q.mVector.w;
+ mVector.z = x * q.mVector.y - y * q.mVector.x + w * q.mVector.z + z * q.mVector.w;
return *this;
}
-const Quaternion& Quaternion::operator*=( float scale )
+const Quaternion& Quaternion::operator*=(float scale)
{
- mVector*=scale; return *this;
+ mVector *= scale;
+ return *this;
}
-const Quaternion& Quaternion::operator/=( float scale )
+const Quaternion& Quaternion::operator/=(float scale)
{
- mVector/=scale; return *this;
+ mVector /= scale;
+ return *this;
}
-bool Quaternion::operator==( const Quaternion& rhs ) const
+bool Quaternion::operator==(const Quaternion& rhs) const
{
- return ( ( fabsf(mVector.x - rhs.mVector.x) < Math::MACHINE_EPSILON_1 &&
- fabsf(mVector.y - rhs.mVector.y) < Math::MACHINE_EPSILON_1 &&
- fabsf(mVector.z - rhs.mVector.z) < Math::MACHINE_EPSILON_1 &&
- fabsf(mVector.w - rhs.mVector.w) < Math::MACHINE_EPSILON_1 ) ||
- // Or equal to negation of rhs
- ( fabsf(mVector.x + rhs.mVector.x) < Math::MACHINE_EPSILON_1 &&
- fabsf(mVector.y + rhs.mVector.y) < Math::MACHINE_EPSILON_1 &&
- fabsf(mVector.z + rhs.mVector.z) < Math::MACHINE_EPSILON_1 &&
- fabsf(mVector.w + rhs.mVector.w) < Math::MACHINE_EPSILON_1 )
- );
+ return ((fabsf(mVector.x - rhs.mVector.x) < Math::MACHINE_EPSILON_1 &&
+ fabsf(mVector.y - rhs.mVector.y) < Math::MACHINE_EPSILON_1 &&
+ fabsf(mVector.z - rhs.mVector.z) < Math::MACHINE_EPSILON_1 &&
+ fabsf(mVector.w - rhs.mVector.w) < Math::MACHINE_EPSILON_1) ||
+ // Or equal to negation of rhs
+ (fabsf(mVector.x + rhs.mVector.x) < Math::MACHINE_EPSILON_1 &&
+ fabsf(mVector.y + rhs.mVector.y) < Math::MACHINE_EPSILON_1 &&
+ fabsf(mVector.z + rhs.mVector.z) < Math::MACHINE_EPSILON_1 &&
+ fabsf(mVector.w + rhs.mVector.w) < Math::MACHINE_EPSILON_1));
}
-bool Quaternion::operator!=( const Quaternion& rhs ) const
+bool Quaternion::operator!=(const Quaternion& rhs) const
{
return !operator==(rhs);
}
float Quaternion::Length() const
{
- return static_cast< float >( sqrt(mVector.w * mVector.w + mVector.Dot(mVector) ) );
+ return static_cast<float>(sqrt(mVector.w * mVector.w + mVector.Dot(mVector)));
}
float Quaternion::LengthSquared() const
{
- return static_cast< float >( mVector.w * mVector.w + mVector.Dot(mVector) );
+ return static_cast<float>(mVector.w * mVector.w + mVector.Dot(mVector));
}
void Quaternion::Normalize()
{
- *this/=Length();
+ *this /= Length();
}
Quaternion Quaternion::Normalized() const
{
- return *this/Length();
+ return *this / Length();
}
void Quaternion::Conjugate()
void Quaternion::Invert()
{
Conjugate();
- *this/=LengthSquared();
+ *this /= LengthSquared();
}
Quaternion Quaternion::Log() const
{
- float a = acosf(mVector.w);
- float sina = sinf(a);
+ float a = acosf(mVector.w);
+ float sina = sinf(a);
Quaternion ret;
ret.mVector.w = 0;
- if (fabsf(sina) >= Math::MACHINE_EPSILON_1)
+ if(fabsf(sina) >= Math::MACHINE_EPSILON_1)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,4);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 4);
float angleBySinAngle = a * (1.0f / sina);
- ret.mVector.x = mVector.x * angleBySinAngle;
- ret.mVector.y = mVector.y * angleBySinAngle;
- ret.mVector.z = mVector.z * angleBySinAngle;
+ ret.mVector.x = mVector.x * angleBySinAngle;
+ ret.mVector.y = mVector.y * angleBySinAngle;
+ ret.mVector.z = mVector.z * angleBySinAngle;
}
else
{
- ret.mVector.x= ret.mVector.y= ret.mVector.z= 0;
+ ret.mVector.x = ret.mVector.y = ret.mVector.z = 0;
}
return ret;
}
Quaternion Quaternion::Exp() const
{
- DALI_ASSERT_ALWAYS( EqualsZero( mVector.w ) && "Cannot perform Exponent" );
+ DALI_ASSERT_ALWAYS(EqualsZero(mVector.w) && "Cannot perform Exponent");
- float a = mVector.Length();
- float sina = sinf(a);
+ float a = mVector.Length();
+ float sina = sinf(a);
Quaternion ret;
ret.mVector.w = cosf(a);
- if (a >= Math::MACHINE_EPSILON_1)
+ if(a >= Math::MACHINE_EPSILON_1)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,4);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 4);
float sinAOverA = sina * (1.0f / a);
- ret.mVector.x = mVector.x * sinAOverA;
- ret.mVector.y = mVector.y * sinAOverA;
- ret.mVector.z = mVector.z * sinAOverA;
+ ret.mVector.x = mVector.x * sinAOverA;
+ ret.mVector.y = mVector.y * sinAOverA;
+ ret.mVector.z = mVector.z * sinAOverA;
}
else
{
return ret;
}
-float Quaternion::Dot( const Quaternion& q1, const Quaternion& q2 )
+float Quaternion::Dot(const Quaternion& q1, const Quaternion& q2)
{
return q1.mVector.Dot4(q2.mVector);
}
-Quaternion Quaternion::Lerp(const Quaternion& q1, const Quaternion& q2, float t )
+Quaternion Quaternion::Lerp(const Quaternion& q1, const Quaternion& q2, float t)
{
- return (q1*(1.0f-t) + q2*t).Normalized();
+ return (q1 * (1.0f - t) + q2 * t).Normalized();
}
-Quaternion Quaternion::Slerp( const Quaternion& q1, const Quaternion& q2, float progress )
+Quaternion Quaternion::Slerp(const Quaternion& q1, const Quaternion& q2, float progress)
{
Quaternion q3;
- float cosTheta = Quaternion::Dot(q1, q2);
+ float cosTheta = Quaternion::Dot(q1, q2);
/**
* If cos(theta) < 0, q1 and q2 are more than 90 degrees apart,
* so invert one to reduce spinning.
*/
- if (cosTheta < 0.0f)
+ if(cosTheta < 0.0f)
{
cosTheta = -cosTheta;
- q3 = -q2;
+ q3 = -q2;
}
else
{
q3 = q2;
}
- if (fabsf(cosTheta) < 0.95f)
+ if(fabsf(cosTheta) < 0.95f)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,5);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 5);
// Normal SLERP
- float sine = sqrtf(1.0f - cosTheta*cosTheta);
- float angle = atan2f(sine, cosTheta);
+ float sine = sqrtf(1.0f - cosTheta * cosTheta);
+ float angle = atan2f(sine, cosTheta);
float invSine = 1.0f / sine;
- float coeff0 = sinf((1.0f - progress) * angle) * invSine;
- float coeff1 = sinf(progress * angle) * invSine;
+ float coeff0 = sinf((1.0f - progress) * angle) * invSine;
+ float coeff1 = sinf(progress * angle) * invSine;
- return q1*coeff0 + q3*coeff1;
+ return q1 * coeff0 + q3 * coeff1;
}
else
{
// If the angle is small, use linear interpolation
- Quaternion result = q1*(1.0f - progress) + q3*progress;
+ Quaternion result = q1 * (1.0f - progress) + q3 * progress;
return result.Normalized();
}
}
-Quaternion Quaternion::SlerpNoInvert( const Quaternion& q1, const Quaternion& q2, float t )
+Quaternion Quaternion::SlerpNoInvert(const Quaternion& q1, const Quaternion& q2, float t)
{
float cosTheta = Quaternion::Dot(q1, q2);
- if (cosTheta > -0.95f && cosTheta < 0.95f)
+ if(cosTheta > -0.95f && cosTheta < 0.95f)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,2);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 2);
float theta = acosf(cosTheta);
- return (q1*sinf(theta*(1.0f-t)) + q2*sinf(theta*t))/sinf(theta);
+ return (q1 * sinf(theta * (1.0f - t)) + q2 * sinf(theta * t)) / sinf(theta);
}
else
{
}
}
-Quaternion Quaternion::Squad( const Quaternion& start, const Quaternion& end, const Quaternion& ctrl1, const Quaternion& ctrl2, float t )
+Quaternion Quaternion::Squad(const Quaternion& start, const Quaternion& end, const Quaternion& ctrl1, const Quaternion& ctrl2, float t)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,2);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 2);
- Quaternion c = SlerpNoInvert( start, end, t );
- Quaternion d = SlerpNoInvert( ctrl1, ctrl2, t );
- return SlerpNoInvert( c, d, 2*t*(1-t) );
+ Quaternion c = SlerpNoInvert(start, end, t);
+ Quaternion d = SlerpNoInvert(ctrl1, ctrl2, t);
+ return SlerpNoInvert(c, d, 2 * t * (1 - t));
}
-float Quaternion::AngleBetween( const Quaternion& q1, const Quaternion& q2 )
+float Quaternion::AngleBetween(const Quaternion& q1, const Quaternion& q2)
{
Quaternion from(q1);
Quaternion to(q2);
//Formula for angle θ between two quaternion is:
//θ = cos^−1 (2⟨q1,q2⟩^2 − 1), Where (q1,q2) is inner product of the quaternions.
- float X = from.mVector.Dot4(to.mVector);
- float theta = acosf( (2 * X * X) - 1); // float arc cosine
+ float X = from.mVector.Dot4(to.mVector);
+ float theta = acosf((2 * X * X) - 1); // float arc cosine
return theta;
}
-Vector4 Quaternion::Rotate( const Vector4& vector ) const
+Vector4 Quaternion::Rotate(const Vector4& vector) const
{
Quaternion V(0.0f, vector.x, vector.y, vector.z);
Quaternion conjugate(*this);
return (*this * V * conjugate).mVector;
}
-Vector3 Quaternion::Rotate( const Vector3& vector ) const
+Vector3 Quaternion::Rotate(const Vector3& vector) const
{
Quaternion V(0.0f, vector.x, vector.y, vector.z);
Quaternion conjugate(*this);
return Vector3((*this * V * conjugate).mVector);
}
-void Quaternion::SetFromAxes( const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis )
+void Quaternion::SetFromAxes(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis)
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,4);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 4);
float t = xAxis.x + yAxis.y + zAxis.z;
- if ( t > 0.0f ) // w is largest
+ if(t > 0.0f) // w is largest
{
- float root = sqrtf( t + 1.0f );
+ float root = sqrtf(t + 1.0f);
float one_over_4w = 0.5f / root;
- mVector.x = ( yAxis.z - zAxis.y ) * one_over_4w;
- mVector.y = ( zAxis.x - xAxis.z ) * one_over_4w;
- mVector.z = ( xAxis.y - yAxis.x ) * one_over_4w;
- mVector.w = root * 0.5f;
+ mVector.x = (yAxis.z - zAxis.y) * one_over_4w;
+ mVector.y = (zAxis.x - xAxis.z) * one_over_4w;
+ mVector.z = (xAxis.y - yAxis.x) * one_over_4w;
+ mVector.w = root * 0.5f;
}
- else if( zAxis.z > xAxis.x && zAxis.z > yAxis.y ) // z is largest
+ else if(zAxis.z > xAxis.x && zAxis.z > yAxis.y) // z is largest
{
- float root = sqrtf( zAxis.z - xAxis.x - yAxis.y + 1.0f );
+ float root = sqrtf(zAxis.z - xAxis.x - yAxis.y + 1.0f);
float one_over_4w = 0.5f / root;
- mVector.x = ( xAxis.z + zAxis.x ) * one_over_4w;
- mVector.y = ( yAxis.z + zAxis.y ) * one_over_4w;
- mVector.z = root * 0.5f;
- mVector.w = ( xAxis.y - yAxis.x ) * one_over_4w;
+ mVector.x = (xAxis.z + zAxis.x) * one_over_4w;
+ mVector.y = (yAxis.z + zAxis.y) * one_over_4w;
+ mVector.z = root * 0.5f;
+ mVector.w = (xAxis.y - yAxis.x) * one_over_4w;
}
- else if( yAxis.y > xAxis.x ) // y is largest
+ else if(yAxis.y > xAxis.x) // y is largest
{
- float root = sqrtf(yAxis.y - zAxis.z - xAxis.x + 1.0f );
+ float root = sqrtf(yAxis.y - zAxis.z - xAxis.x + 1.0f);
float one_over_4w = 0.5f / root;
- mVector.x = ( xAxis.y + yAxis.x ) * one_over_4w;
+ mVector.x = (xAxis.y + yAxis.x) * one_over_4w;
mVector.y = root * 0.5f;
- mVector.z = ( zAxis.y + yAxis.z ) * one_over_4w;
- mVector.w = ( zAxis.x - xAxis.z ) * one_over_4w;
+ mVector.z = (zAxis.y + yAxis.z) * one_over_4w;
+ mVector.w = (zAxis.x - xAxis.z) * one_over_4w;
}
- else // x is largest
+ else // x is largest
{
- float root = sqrtf( xAxis.x - yAxis.y - zAxis.z + 1.0f );
+ float root = sqrtf(xAxis.x - yAxis.y - zAxis.z + 1.0f);
float one_over_4w = 0.5f / root;
- mVector.x = root * 0.5f;
- mVector.y = ( yAxis.x + xAxis.y ) * one_over_4w;
- mVector.z = ( zAxis.x + xAxis.z ) * one_over_4w;
- mVector.w = ( yAxis.z - zAxis.y ) * one_over_4w;
+ mVector.x = root * 0.5f;
+ mVector.y = (yAxis.x + xAxis.y) * one_over_4w;
+ mVector.z = (zAxis.x + xAxis.z) * one_over_4w;
+ mVector.w = (yAxis.z - zAxis.y) * one_over_4w;
}
Normalize();
}
-std::ostream& operator<<( std::ostream& o, const Quaternion& quaternion )
+std::ostream& operator<<(std::ostream& o, const Quaternion& quaternion)
{
Vector3 axis;
- Radian angleRadians;
+ Radian angleRadians;
- quaternion.ToAxisAngle( axis, angleRadians );
- Degree degrees( angleRadians );
+ quaternion.ToAxisAngle(axis, angleRadians);
+ Degree degrees(angleRadians);
return o << "[ Axis: [" << axis.x << ", " << axis.y << ", " << axis.z << "], Angle: " << degrees.degree << " degrees ]";
}
class DALI_CORE_API Quaternion
{
public:
-
/**
* @brief Default Constructor.
* @SINCE_1_0.0
* @param[in] jBySineTheta
* @param[in] kBySineTheta
*/
- Quaternion( float cosThetaBy2, float iBySineTheta, float jBySineTheta, float kBySineTheta );
+ Quaternion(float cosThetaBy2, float iBySineTheta, float jBySineTheta, float kBySineTheta);
/**
* @brief Constructs from a quaternion represented by a vector.
* @SINCE_1_0.0
* @param[in] vector x,y,z fields represent i,j,k coefficients, w represents cos(theta/2)
*/
- explicit Quaternion( const Vector4& vector );
+ explicit Quaternion(const Vector4& vector);
/**
* @brief Constructor from an axis and angle.
* @param[in] angle The angle around the axis
* @param[in] axis The vector of the axis
*/
- Quaternion( Radian angle, const Vector3& axis );
+ Quaternion(Radian angle, const Vector3& axis);
/**
* @brief Constructs from Euler angles.
* @param[in] yaw
* @param[in] roll
*/
- Quaternion( Radian pitch, Radian yaw, Radian roll );
+ Quaternion(Radian pitch, Radian yaw, Radian roll);
/**
* @brief Constructs from a matrix.
* @param[in] yAxis The Y axis
* @param[in] zAxis The Z axis
*/
- explicit Quaternion( const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis );
+ explicit Quaternion(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis);
/**
* @brief Constructs quaternion which describes minimum rotation to align v0 with v1.
* @pre v0 and v1 should be normalized
*
*/
- explicit Quaternion( const Vector3& v0, const Vector3& v1 );
+ explicit Quaternion(const Vector3& v0, const Vector3& v1);
/**
* @brief Destructor, nonvirtual as this is not a base class.
*/
~Quaternion();
-// Constants
+ // Constants
static const Quaternion IDENTITY; ///< (0.0f,0.0f,0.0f,1.0f)
* @param[out] angle Angle in radians
* @return True if converted correctly
*/
- bool ToAxisAngle( Vector3& axis, Radian& angle ) const;
+ bool ToAxisAngle(Vector3& axis, Radian& angle) const;
/**
* @brief Returns the quaternion as a vector.
* @param[in] yaw
* @param[in] roll
*/
- void SetEuler( Radian pitch, Radian yaw, Radian roll );
+ void SetEuler(Radian pitch, Radian yaw, Radian roll);
/**
* @brief Returns the Euler angles from a rotation Quaternion.
* @param[in] other The quaternion to add
* @return A quaternion containing the result of the addition
*/
- const Quaternion operator+( const Quaternion& other ) const;
+ const Quaternion operator+(const Quaternion& other) const;
/**
* @brief Subtraction operator.
* @param[in] other The quaternion to subtract
* @return A quaternion containing the result of the subtract
*/
- const Quaternion operator-( const Quaternion& other ) const;
+ const Quaternion operator-(const Quaternion& other) const;
/**
* @brief Multiplication operator.
* @param[in] other The quaternion to multiply
* @return A quaternion containing the result
*/
- const Quaternion operator*( const Quaternion& other ) const;
+ const Quaternion operator*(const Quaternion& other) const;
/**
* @brief Multiplication operator.
* @param[in] other The vector to multiply
* @return A vector containing the result of the multiplication
*/
- Vector3 operator*( const Vector3& other ) const;
+ Vector3 operator*(const Vector3& other) const;
/**
* @brief Division operator.
* @param[in] other A quaternion to divide by
* @return A quaternion containing the result
*/
- const Quaternion operator/( const Quaternion& other ) const;
+ const Quaternion operator/(const Quaternion& other) const;
/**
* @brief Scale operator.
* @param[in] scale A value to scale by
* @return A quaternion containing the result
*/
- const Quaternion operator*( float scale ) const;
+ const Quaternion operator*(float scale) const;
/**
* @brief Scale operator.
* @param[in] scale A value to scale by
* @return A quaternion containing the result
*/
- const Quaternion operator/( float scale ) const;
+ const Quaternion operator/(float scale) const;
/**
* @brief Unary Negation operator.
* @param[in] other The quaternion to add
* @return A reference to this
*/
- const Quaternion& operator+=( const Quaternion& other );
+ const Quaternion& operator+=(const Quaternion& other);
/**
* @brief Subtraction with Assignment operator.
* @param[in] other The quaternion to subtract
* @return A reference to this
*/
- const Quaternion& operator-=( const Quaternion& other );
+ const Quaternion& operator-=(const Quaternion& other);
/**
* @brief Multiplication with Assignment operator.
* @param[in] other The quaternion to multiply
* @return A reference to this
*/
- const Quaternion& operator*=( const Quaternion& other );
+ const Quaternion& operator*=(const Quaternion& other);
/**
* @brief Scale with Assignment operator.
* @param[in] scale the value to scale by
* @return A reference to this
*/
- const Quaternion& operator*=( float scale );
+ const Quaternion& operator*=(float scale);
/**
* @brief Scale with Assignment operator.
* @param[in] scale The value to scale by
* @return A reference to this
*/
- const Quaternion& operator/=( float scale );
+ const Quaternion& operator/=(float scale);
/**
* @brief Equality operator.
* @param[in] rhs The quaternion to compare with
* @return True if the quaternions are equal
*/
- bool operator==( const Quaternion& rhs ) const;
+ bool operator==(const Quaternion& rhs) const;
/**
* @brief Inequality operator.
* @param[in] rhs The quaternion to compare with
* @return True if the quaternions are not equal
*/
- bool operator!=( const Quaternion& rhs ) const;
+ bool operator!=(const Quaternion& rhs) const;
/**
* @brief Returns the length of the quaternion.
* @param[in] q2 The second quaternion
* @return The dot product of the two quaternions
*/
- static float Dot( const Quaternion &q1, const Quaternion &q2 );
+ static float Dot(const Quaternion& q1, const Quaternion& q2);
/**
* @brief Linear Interpolation (using a straight line between the two quaternions).
* @param[in] t A progress value between 0 and 1
* @return The interpolated quaternion
*/
- static Quaternion Lerp( const Quaternion &q1, const Quaternion &q2, float t );
+ static Quaternion Lerp(const Quaternion& q1, const Quaternion& q2, float t);
/**
* @brief Spherical Linear Interpolation (using the shortest arc of a great circle between
* @param[in] progress A progress value between 0 and 1
* @return The interpolated quaternion
*/
- static Quaternion Slerp( const Quaternion &q1, const Quaternion &q2, float progress );
+ static Quaternion Slerp(const Quaternion& q1, const Quaternion& q2, float progress);
/**
* @brief This version of Slerp, used by Squad, does not check for theta > 90.
* @param[in] t A progress value between 0 and 1
* @return The interpolated quaternion
*/
- static Quaternion SlerpNoInvert( const Quaternion &q1, const Quaternion &q2, float t );
+ static Quaternion SlerpNoInvert(const Quaternion& q1, const Quaternion& q2, float t);
/**
* @brief Spherical Cubic Interpolation.
* @param[in] t A progress value between 0 and 1
* @return The interpolated quaternion
*/
- static Quaternion Squad( const Quaternion& start, const Quaternion& end, const Quaternion& ctrl1, const Quaternion& ctrl2, float t );
+ static Quaternion Squad(const Quaternion& start, const Quaternion& end, const Quaternion& ctrl1, const Quaternion& ctrl2, float t);
/**
* @brief Returns the shortest angle between two quaternions in Radians.
* @param[in] q2 The second quaternion
* @return The angle between the two quaternions
*/
- static float AngleBetween( const Quaternion& q1, const Quaternion& q2 );
+ static float AngleBetween(const Quaternion& q1, const Quaternion& q2);
/**
* @brief Rotates v by this Quaternion (Quaternion must be unit).
* @param[in] vector A vector to rotate
* @return The rotated vector
*/
- Vector4 Rotate( const Vector4& vector ) const;
+ Vector4 Rotate(const Vector4& vector) const;
/**
* @brief Rotates v by this Quaternion (Quaternion must be unit).
* @param[in] vector A vector to rotate
* @return The rotated vector
*/
- Vector3 Rotate( const Vector3& vector ) const;
+ Vector3 Rotate(const Vector3& vector) const;
private:
-
/// @cond internal
/**
* @brief Sets the quaternion from 3 orthonormal axes.
* @param[in] yAxis The Y axis
* @param[in] zAxis The Z axis
*/
- DALI_INTERNAL void SetFromAxes( const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis );
+ DALI_INTERNAL void SetFromAxes(const Vector3& xAxis, const Vector3& yAxis, const Vector3& zAxis);
/// @endcond
public:
-
- Quaternion( const Quaternion& ) = default; ///< Default copy constructor
- Quaternion( Quaternion&& ) = default; ///< Default move constructor
- Quaternion& operator=( const Quaternion& ) = default; ///< Default copy assignment operator
- Quaternion& operator=( Quaternion&& ) = default; ///< Default move assignment operator
+ Quaternion(const Quaternion&) = default; ///< Default copy constructor
+ Quaternion(Quaternion&&) = default; ///< Default move constructor
+ Quaternion& operator=(const Quaternion&) = default; ///< Default copy assignment operator
+ Quaternion& operator=(Quaternion&&) = default; ///< Default move assignment operator
public:
-
- Vector4 mVector; ///< w component is s ( = cos(theta/2.0) )
+ Vector4 mVector; ///< w component is s ( = cos(theta/2.0) )
};
/**
* @param[in] quaternion The quaternion to print
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Quaternion& quaternion);
+DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Quaternion& quaternion);
// Allow Quaternion to be treated as a POD type
-template <> struct TypeTraits< Quaternion > : public BasicTypes< Quaternion > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Quaternion> : public BasicTypes<Quaternion>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
// INTERNAL INCLUDES
#include <dali/public-api/common/constants.h>
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/math/degree.h>
+#include <dali/public-api/math/math-utils.h>
namespace Dali
{
* @SINCE_1_0.0
*/
Radian()
- : radian( 0.f )
- { }
+ : radian(0.f)
+ {
+ }
/**
* @brief Creates an angle in radians.
* @SINCE_1_0.0
* @param[in] value The initial value in radians
*/
- explicit constexpr Radian( float value )
- : radian( value )
- { }
+ explicit constexpr Radian(float value)
+ : radian(value)
+ {
+ }
/**
* @brief Creates an angle in radians from an angle in degrees.
* @SINCE_1_0.0
* @param[in] degree The initial value in degrees
*/
- Radian( Degree degree )
- : radian( degree.degree * Math::PI_OVER_180 )
- { }
+ Radian(Degree degree)
+ : radian(degree.degree * Math::PI_OVER_180)
+ {
+ }
/**
* @brief Assigns an angle from a float value.
* @param[in] value Float value in radians
* @return A reference to this
*/
- Radian& operator=( float value )
+ Radian& operator=(float value)
{
radian = value;
return *this;
* @param[in] degree The value in degrees
* @return A reference to this
*/
- Radian& operator=( Degree degree )
+ Radian& operator=(Degree degree)
{
radian = degree.degree * Math::PI_OVER_180;
return *this;
}
public:
-
- Radian( const Radian& ) = default; ///< Default copy constructor
- Radian( Radian&& ) = default; ///< Default move constructor
- Radian& operator=( const Radian& ) = default; ///< Default copy assignment operator
- Radian& operator=( Radian&& ) = default; ///< Default move assignment operator
+ Radian(const Radian&) = default; ///< Default copy constructor
+ Radian(Radian&&) = default; ///< Default move constructor
+ Radian& operator=(const Radian&) = default; ///< Default copy assignment operator
+ Radian& operator=(Radian&&) = default; ///< Default move assignment operator
public:
-
// member data
float radian; ///< The value in radians
-
};
// compiler generated destructor, copy constructor and assignment operators are ok as this class is POD
* @param[in] rhs Radian to compare to
* @return True if the values are identical
*/
-inline bool operator==( Radian lhs, Radian rhs )
+inline bool operator==(Radian lhs, Radian rhs)
{
- return fabsf( lhs.radian - rhs.radian ) < Math::MACHINE_EPSILON_10; // expect Radian angles to be between 0 and 10 (multiplies of Math::PI)
+ return fabsf(lhs.radian - rhs.radian) < Math::MACHINE_EPSILON_10; // expect Radian angles to be between 0 and 10 (multiplies of Math::PI)
}
/**
* @param[in] rhs Radian to compare to
* @return True if the values are not identical
*/
-inline bool operator!=( Radian lhs, Radian rhs )
+inline bool operator!=(Radian lhs, Radian rhs)
{
- return !( operator==( lhs, rhs ) );
+ return !(operator==(lhs, rhs));
}
/**
* @param[in] rhs Degree to compare to
* @return True if the values are identical
*/
-inline bool operator==( Radian lhs, Degree rhs )
+inline bool operator==(Radian lhs, Degree rhs)
{
- return fabsf( lhs.radian - Radian( rhs ).radian ) < Math::MACHINE_EPSILON_100; // expect Degree angles to be between 0 and 999
+ return fabsf(lhs.radian - Radian(rhs).radian) < Math::MACHINE_EPSILON_100; // expect Degree angles to be between 0 and 999
}
/**
* @param[in] rhs Degree to compare to
* @return True if the values are not identical
*/
-inline bool operator!=( Radian lhs, Degree rhs )
+inline bool operator!=(Radian lhs, Degree rhs)
{
- return !( operator==( lhs, rhs ) );
+ return !(operator==(lhs, rhs));
}
/**
* @param[in] rhs Radian to compare to
* @return True if the values are identical
*/
-inline bool operator==( Degree lhs, Radian rhs )
+inline bool operator==(Degree lhs, Radian rhs)
{
- return fabsf( Radian( lhs ).radian - rhs.radian ) < Math::MACHINE_EPSILON_100; // expect Degree angles to be between 0 and 999
+ return fabsf(Radian(lhs).radian - rhs.radian) < Math::MACHINE_EPSILON_100; // expect Degree angles to be between 0 and 999
}
/**
* @param[in] rhs Radian to compare to
* @return True if the values are not identical
*/
-inline bool operator!=( Degree lhs, Radian rhs )
+inline bool operator!=(Degree lhs, Radian rhs)
{
- return !( operator==( lhs, rhs ) );
+ return !(operator==(lhs, rhs));
}
/**
* @param[in] rhs Radian to compare to
* @return True if lhs is greater than rhs
*/
-inline bool operator>( Radian lhs, Radian rhs )
+inline bool operator>(Radian lhs, Radian rhs)
{
return lhs.radian > rhs.radian;
}
* @param[in] rhs Degree to compare to
* @return True if lhs is greater than rhs
*/
-inline bool operator>( Radian lhs, Degree rhs )
+inline bool operator>(Radian lhs, Degree rhs)
{
return lhs.radian > Radian(rhs).radian;
}
* @param[in] rhs Degree to compare to
* @return True if lhs is greater than rhs
*/
-inline bool operator>( Degree lhs, Radian rhs )
+inline bool operator>(Degree lhs, Radian rhs)
{
return Radian(lhs).radian > rhs.radian;
}
* @param[in] rhs Radian to compare to
* @return True if lhs is less than rhs
*/
-inline bool operator<( Radian lhs, Radian rhs )
+inline bool operator<(Radian lhs, Radian rhs)
{
return lhs.radian < rhs.radian;
}
* @param[in] rhs Degree to compare to
* @return True if lhs is less than rhs
*/
-inline bool operator<( Radian lhs, Degree rhs )
+inline bool operator<(Radian lhs, Degree rhs)
{
return lhs.radian < Radian(rhs).radian;
}
* @param[in] rhs Radian to compare to
* @return True if lhs is less than rhs
*/
-inline bool operator<( Degree lhs, Radian rhs )
+inline bool operator<(Degree lhs, Radian rhs)
{
return Radian(lhs).radian < rhs.radian;
}
* @param[in] rhs float to multiply
* @return Result of the multiplication
*/
-inline Radian operator*( Radian lhs, float rhs )
+inline Radian operator*(Radian lhs, float rhs)
{
- return Radian( lhs.radian * rhs );
+ return Radian(lhs.radian * rhs);
}
/**
* @param[in] in Radian to negate
* @return The negative angle
*/
-inline Radian operator-( Radian in )
+inline Radian operator-(Radian in)
{
- return Radian( -in.radian );
+ return Radian(-in.radian);
}
/**
* @param max value
* @return The resulting radian
*/
-inline Radian Clamp( Radian angle, float min, float max )
+inline Radian Clamp(Radian angle, float min, float max)
{
- return Radian( Clamp<float>( angle.radian, min, max ) );
+ return Radian(Clamp<float>(angle.radian, min, max));
}
// useful constant angles
-inline constexpr Radian ANGLE_360( Math::PI * 2.f );
-inline constexpr Radian ANGLE_315( Math::PI * 1.75f );
-inline constexpr Radian ANGLE_270( Math::PI * 1.5f );
-inline constexpr Radian ANGLE_225( Math::PI * 1.25f );
-inline constexpr Radian ANGLE_180( Math::PI );
-inline constexpr Radian ANGLE_135( Math::PI * 0.75f );
-inline constexpr Radian ANGLE_120( Math::PI * 2.f/3.f );
-inline constexpr Radian ANGLE_90 ( Math::PI_2 );
-inline constexpr Radian ANGLE_60 ( Math::PI / 3.f );
-inline constexpr Radian ANGLE_45 ( Math::PI_4 );
-inline constexpr Radian ANGLE_30 ( Math::PI / 6.f );
-inline constexpr Radian ANGLE_0 ( 0.0f );
+inline constexpr Radian ANGLE_360(Math::PI * 2.f);
+inline constexpr Radian ANGLE_315(Math::PI * 1.75f);
+inline constexpr Radian ANGLE_270(Math::PI * 1.5f);
+inline constexpr Radian ANGLE_225(Math::PI * 1.25f);
+inline constexpr Radian ANGLE_180(Math::PI);
+inline constexpr Radian ANGLE_135(Math::PI * 0.75f);
+inline constexpr Radian ANGLE_120(Math::PI * 2.f / 3.f);
+inline constexpr Radian ANGLE_90(Math::PI_2);
+inline constexpr Radian ANGLE_60(Math::PI / 3.f);
+inline constexpr Radian ANGLE_45(Math::PI_4);
+inline constexpr Radian ANGLE_30(Math::PI / 6.f);
+inline constexpr Radian ANGLE_0(0.0f);
/**
* @}
#define DALI_RANDOM_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
namespace Random
{
-
/**
* @brief Returns a random number between f0 and f1.
*
// Ensure we initialize only once. As it's inlined, this static variable will exist in the code-block using it, thus,
// will be created and then initialized again when another code-block uses this.
- static bool initialized( false );
- if( !initialized )
+ static bool initialized(false);
+ if(!initialized)
{
- uint32_t seed = static_cast<uint32_t>( time( NULL ) );
- srand( seed );
+ uint32_t seed = static_cast<uint32_t>(time(nullptr));
+ srand(seed);
initialized = true;
}
int32_t randValue = rand();
- return static_cast<float>(randValue & 0xfff) * (1.0f/4095.0f) * (max-min) + min;
+ return static_cast<float>(randValue & 0xfff) * (1.0f / 4095.0f) * (max - min) + min;
}
/**
do
{
axis.x = Range(-1.0f, 1.0f);
- axis.y = Range( 0.0f, 1.0f);
- axis.z = Range( 0.0f, 1.0f);
+ axis.y = Range(0.0f, 1.0f);
+ axis.z = Range(0.0f, 1.0f);
axis.w = 0.0f;
- } while (axis == Vector4::ZERO);
+ } while(axis == Vector4::ZERO);
axis.Normalize();
return axis;
}
// Ensure Rect is maintained as a trivially copyable type
static_assert(std::is_trivially_copyable<Rect<float>>::value);
} // namespace Dali
-
* @brief Template class to create and operate on rectangles.
* @SINCE_1_0.0
*/
-template< typename T = float >
+template<typename T = float>
struct Rect
{
-// Methods
+ // Methods
/**
* @brief Constructor.
* @SINCE_1_9.14
* @param[in] vec4 Vector4 to convert from
*/
- Rect( const Vector4& vec4 )
+ Rect(const Vector4& vec4)
: x(vec4.x),
y(vec4.y),
width(vec4.z),
* @SINCE_1_9.27
* @param[in] rhs The original object
*/
- Rect( const Rect<T>& rhs ) = default;
+ Rect(const Rect<T>& rhs) = default;
/**
* @brief Default copy assignment operator.
* @param[in] rhs The original object
* @return Reference to this
*/
- Rect<T>& operator=( const Rect<T>& rhs ) = default;
+ Rect<T>& operator=(const Rect<T>& rhs) = default;
/**
* @brief Default move constructor.
* @SINCE_1_9.27
* @param[in] rhs The original object
*/
- Rect<T>( Rect<T>&& rhs ) = default;
+ Rect<T>(Rect<T>&& rhs) = default;
/**
* @brief Default move assignment operator.
* @param[in] rhs The original object
* @return Reference to this
*/
- Rect<T>& operator=( Rect<T>&& rhs ) = default;
+ Rect<T>& operator=(Rect<T>&& rhs) = default;
/**
* @brief Assignment operator.
*/
Rect<T>& operator=(const Vector4& vec4)
{
- x = vec4.x;
- y = vec4.y;
- width = vec4.z;
+ x = vec4.x;
+ y = vec4.y;
+ width = vec4.z;
height = vec4.w;
return *this;
*/
void Set(T newX, T newY, T newWidth, T newHeight)
{
- x = newX;
- y = newY;
- width = newWidth;
+ x = newX;
+ y = newY;
+ width = newWidth;
height = newHeight;
}
*/
bool IsEmpty() const
{
- return width == 0 ||
- height == 0;
+ return width == 0 ||
+ height == 0;
}
/**
bool Intersects(const Rect<T>& other) const
{
return (other.x + other.width) > x && other.x < (x + width) &&
- (other.y + other.height) > y && other.y < (y + height);
+ (other.y + other.height) > y && other.y < (y + height);
}
/**
*/
bool Intersect(const Rect<T>& rect)
{
- const int left = std::max(rect.x, x);
- const int top = std::max(rect.y, y);
- const int right = std::min(rect.x + rect.width, x + width);
+ const int left = std::max(rect.x, x);
+ const int top = std::max(rect.y, y);
+ const int right = std::min(rect.x + rect.width, x + width);
const int bottom = std::min(rect.y + rect.height, y + height);
- const int width = right - left;
+ const int width = right - left;
const int height = bottom - top;
- if (!(width < 0 || height < 0))
+ if(!(width < 0 || height < 0))
{
- x = left;
- y = top;
- this->width = width;
+ x = left;
+ y = top;
+ this->width = width;
this->height = height;
return true;
}
*/
void Merge(const Rect<T>& rect)
{
- const int left = std::min(rect.x, x);
- const int top = std::min(rect.y, y);
- const int right = std::max(rect.x + rect.width, x + width);
+ const int left = std::min(rect.x, x);
+ const int top = std::min(rect.y, y);
+ const int right = std::max(rect.x + rect.width, x + width);
const int bottom = std::max(rect.y + rect.height, y + height);
- x = left;
- y = top;
- width = right - left;
- height = bottom - top;
+ x = left;
+ y = top;
+ width = right - left;
+ height = bottom - top;
}
/**
*/
void Inset(T dx, T dy)
{
- const int left = x - dx;
- const int top = y - dy;
- const int right = x + width + dx;
+ const int left = x - dx;
+ const int top = y - dy;
+ const int right = x + width + dx;
const int bottom = y + height + dy;
- x = left;
- y = top;
- width = right - left;
- height = bottom - top;
+ x = left;
+ y = top;
+ width = right - left;
+ height = bottom - top;
}
/**
*/
bool Contains(const Rect<T>& other) const
{
- return other.x >= x && (other.x + other.width) <= (x + width) &&
- other.y >= y && (other.y + other.height) <= (y + height);
+ return other.x >= x && (other.x + other.width) <= (x + width) &&
+ other.y >= y && (other.y + other.height) <= (y + height);
}
-public: // Data
-
+public: // Data
union
{
- T x; ///< X position of the rectangle
- T left; ///< The left value
+ T x; ///< X position of the rectangle
+ T left; ///< The left value
};
union
{
- T y; ///< Y position of the rectangle
- T right; ///< The right value
+ T y; ///< Y position of the rectangle
+ T right; ///< The right value
};
union
* @param[in] rhs Second operand
* @return True if boxes are exactly same
*/
-template< typename T >
-inline bool operator==( const Rect<T>& lhs, const Rect<T>& rhs )
+template<typename T>
+inline bool operator==(const Rect<T>& lhs, const Rect<T>& rhs)
{
- return ( lhs.x == rhs.x )&&
- ( lhs.y == rhs.y )&&
- ( lhs.width == rhs.width )&&
- ( lhs.height == rhs.height );
+ return (lhs.x == rhs.x) &&
+ (lhs.y == rhs.y) &&
+ (lhs.width == rhs.width) &&
+ (lhs.height == rhs.height);
}
/**
* @param[in] rhs The second rectangle
* @return True if rectangles are not identical
*/
-template< typename T >
-inline bool operator!=( const Rect<T>& lhs, const Rect<T>& rhs )
+template<typename T>
+inline bool operator!=(const Rect<T>& lhs, const Rect<T>& rhs)
{
return !(lhs == rhs);
}
* @return True if rectangles are exactly same
*/
template<>
-inline bool operator==( const Rect<float>& lhs, const Rect<float>& rhs )
+inline bool operator==(const Rect<float>& lhs, const Rect<float>& rhs)
{
- return ( fabsf( lhs.x - rhs.x ) < GetRangedEpsilon(lhs.x, rhs.x) )&&
- ( fabsf( lhs.y - rhs.y ) < GetRangedEpsilon(lhs.y, rhs.y) )&&
- ( fabsf( lhs.width - rhs.width ) < GetRangedEpsilon(lhs.width, rhs.width) )&&
- ( fabsf( lhs.height - rhs.height ) < GetRangedEpsilon(lhs.height, rhs.height) );
+ return (fabsf(lhs.x - rhs.x) < GetRangedEpsilon(lhs.x, rhs.x)) &&
+ (fabsf(lhs.y - rhs.y) < GetRangedEpsilon(lhs.y, rhs.y)) &&
+ (fabsf(lhs.width - rhs.width) < GetRangedEpsilon(lhs.width, rhs.width)) &&
+ (fabsf(lhs.height - rhs.height) < GetRangedEpsilon(lhs.height, rhs.height));
}
/**
template<>
inline bool Rect<float>::IsEmpty() const
{
- return (fabsf(width) <= GetRangedEpsilon(width, width)
- ||
+ return (fabsf(width) <= GetRangedEpsilon(width, width) ||
fabsf(height) <= GetRangedEpsilon(height, height));
}
* @param[in] rectangle the rectangle to output
* @return The output stream operator
*/
-template< typename T >
-inline std::ostream& operator<< (std::ostream& stream, const Rect<T>& rectangle)
+template<typename T>
+inline std::ostream& operator<<(std::ostream& stream, const Rect<T>& rectangle)
{
return stream << "[" << rectangle.x << ", " << rectangle.y << ", " << rectangle.width << ", " << rectangle.height << "]";
}
* @brief Default constructor for the (0, 0) tuple.
* @SINCE_1_0.0
*/
- Uint16Pair() : mData(0) {}
+ Uint16Pair()
+ : mData(0)
+ {
+ }
/**
* @brief Constructor taking separate x and y (width and height) parameters.
* @param[in] width The width or X dimension of the tuple. Make sure it is less than 65536
* @param[in] height The height or Y dimension of the tuple. Make sure it is less than 65536
*/
- Uint16Pair( uint32_t width, uint32_t height )
+ Uint16Pair(uint32_t width, uint32_t height)
{
- DALI_ASSERT_DEBUG( width < ( 1u << 16 ) && "Width parameter not representable." );
- DALI_ASSERT_DEBUG( height < ( 1u << 16 ) && "Height parameter not representable." );
+ DALI_ASSERT_DEBUG(width < (1u << 16) && "Width parameter not representable.");
+ DALI_ASSERT_DEBUG(height < (1u << 16) && "Height parameter not representable.");
/* Do equivalent of the code below with one aligned memory access:
* mComponents[0] = width;
* @SINCE_1_1.13
* @param[in] width The x dimension to be stored in this 2-tuple
*/
- void SetWidth( uint16_t width )
+ void SetWidth(uint16_t width)
{
mComponents[0] = width;
}
* @SINCE_1_1.13
* @param[in] height The y dimension to be stored in this 2-tuple
*/
- void SetHeight( uint16_t height )
+ void SetHeight(uint16_t height)
{
mComponents[1] = height;
}
* @SINCE_1_1.14
* @param[in] x The x dimension to be stored in this 2-tuple
*/
- void SetX( uint16_t x )
+ void SetX(uint16_t x)
{
mComponents[0] = x;
}
* @SINCE_1_0.0
* @return X
*/
- uint16_t GetX() const
+ uint16_t GetX() const
{
return mComponents[0];
}
* @SINCE_1_1.14
* @param[in] y The y dimension to be stored in this 2-tuple
*/
- void SetY( uint16_t y )
+ void SetY(uint16_t y)
{
mComponents[1] = y;
}
* @param[in] rhs A reference for comparison
* @return True if same
*/
- bool operator==( const Uint16Pair& rhs ) const
+ bool operator==(const Uint16Pair& rhs) const
{
return mData == rhs.mData;
}
* @param[in] rhs A reference for comparison
* @return True if different
*/
- bool operator!=( const Uint16Pair& rhs ) const
+ bool operator!=(const Uint16Pair& rhs) const
{
return mData != rhs.mData;
}
* @param[in] rhs A reference for comparison
* @return True if less
*/
- bool operator<( const Uint16Pair& rhs ) const
+ bool operator<(const Uint16Pair& rhs) const
{
return mData < rhs.mData;
}
* @param[in] rhs A reference for comparison
* @return True if greater
*/
- bool operator>( const Uint16Pair& rhs ) const
+ bool operator>(const Uint16Pair& rhs) const
{
return mData > rhs.mData;
}
* @return Closest integer value
*/
template<typename FLOAT_VECTOR_N_TYPE>
- static Uint16Pair FromFloatVec2( const FLOAT_VECTOR_N_TYPE& from )
+ static Uint16Pair FromFloatVec2(const FLOAT_VECTOR_N_TYPE& from)
{
- DALI_ASSERT_DEBUG( from.x + 0.5f < 65536.0f );
- DALI_ASSERT_DEBUG( from.y + 0.5f < 65536.0f );
- return Uint16Pair( from.x + 0.5f, from.y + 0.5f );
+ DALI_ASSERT_DEBUG(from.x + 0.5f < 65536.0f);
+ DALI_ASSERT_DEBUG(from.y + 0.5f < 65536.0f);
+ return Uint16Pair(from.x + 0.5f, from.y + 0.5f);
}
/**
* @return Closest integer value
*/
template<typename FLOAT_ARRAY>
- static Uint16Pair FromFloatArray( const FLOAT_ARRAY& from )
+ static Uint16Pair FromFloatArray(const FLOAT_ARRAY& from)
{
- DALI_ASSERT_DEBUG( from[0] + 0.5f < 65536.0f );
- DALI_ASSERT_DEBUG( from[1] + 0.5f < 65536.0f );
- return Uint16Pair( from[0] + 0.5f, from[1] + 0.5f );
+ DALI_ASSERT_DEBUG(from[0] + 0.5f < 65536.0f);
+ DALI_ASSERT_DEBUG(from[1] + 0.5f < 65536.0f);
+ return Uint16Pair(from[0] + 0.5f, from[1] + 0.5f);
}
public:
-
- Uint16Pair( const Uint16Pair& ) = default; ///< Default copy constructor
- Uint16Pair( Uint16Pair&& ) = default; ///< Default move constructor
- Uint16Pair& operator=( const Uint16Pair& ) = default; ///< Default copy assignment operator
- Uint16Pair& operator=( Uint16Pair&& ) = default; ///< Default move assignment operator
+ Uint16Pair(const Uint16Pair&) = default; ///< Default copy constructor
+ Uint16Pair(Uint16Pair&&) = default; ///< Default move constructor
+ Uint16Pair& operator=(const Uint16Pair&) = default; ///< Default copy assignment operator
+ Uint16Pair& operator=(Uint16Pair&&) = default; ///< Default move assignment operator
private:
union
};
// Allow Uint16Pair to be treated as a POD type
-template <> struct TypeTraits< Uint16Pair > : public BasicTypes< Uint16Pair > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Uint16Pair> : public BasicTypes<Uint16Pair>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
#include <ostream>
// INTERNAL INCLUDES
+#include <dali/internal/render/common/performance-monitor.h>
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/math/uint-16-pair.h>
-#include <dali/internal/render/common/performance-monitor.h>
+#include <dali/public-api/math/vector3.h>
namespace Dali
{
-
const Vector2 Vector2::ONE(1.0f, 1.0f);
const Vector2 Vector2::XAXIS(1.0f, 0.0f);
const Vector2 Vector2::YAXIS(0.0f, 1.0f);
return *this;
}
-
bool Vector2::operator==(const Vector2& rhs) const
{
- if (fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x))
+ if(fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x))
{
return false;
}
- if (fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y))
+ if(fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y))
{
return false;
}
float Vector2::LengthSquared() const
{
- return (x*x) + (y*y);
+ return (x * x) + (y * y);
}
void Vector2::Normalize()
{
float length = Length();
- if( ! EqualsZero(length) )
+ if(!EqualsZero(length))
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,2);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 2);
const float inverseLength = 1.0f / length;
x *= inverseLength;
}
}
-void Vector2::Clamp( const Vector2& min, const Vector2& max )
+void Vector2::Clamp(const Vector2& min, const Vector2& max)
{
- Dali::ClampInPlace<float>( x, min.x, max.x );
- Dali::ClampInPlace<float>( y, min.y, max.y );
+ Dali::ClampInPlace<float>(x, min.x, max.x);
+ Dali::ClampInPlace<float>(y, min.y, max.y);
}
-std::ostream& operator<< (std::ostream& o, const Vector2& vector)
+std::ostream& operator<<(std::ostream& o, const Vector2& vector)
{
return o << "[" << vector.x << ", " << vector.y << "]";
}
-Vector2 Clamp( const Vector2& v, const float& min, const float& max )
+Vector2 Clamp(const Vector2& v, const float& min, const float& max)
{
- Vector2 result( v );
- result.Clamp( Vector2( min, min ) , Vector2( max, max ) );
+ Vector2 result(v);
+ result.Clamp(Vector2(min, min), Vector2(max, max));
return result;
}
namespace Dali
{
-
class Uint16Pair;
/**
*/
struct DALI_CORE_API Vector2
{
-// (x width) and (y height) must be consecutive in memory.
-// No other data must be added before (x width) member.
-// No virtual methods must be added to this struct.
+ // (x width) and (y height) must be consecutive in memory.
+ // No other data must be added before (x width) member.
+ // No virtual methods must be added to this struct.
public:
-
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param[in] y y or height component
*/
explicit constexpr Vector2(float x, float y)
- : x(x), y(y)
+ : x(x),
+ y(y)
{
}
*/
Vector2(const Uint16Pair& pair);
-// Constants
+ // Constants
- static const Vector2 ONE; ///< (1.0f,1.0f)
- static const Vector2 XAXIS; ///< Vector representing the X axis
- static const Vector2 YAXIS; ///< Vector representing the Y axis
- static const Vector2 NEGATIVE_XAXIS; ///< Vector representing the negative X axis
- static const Vector2 NEGATIVE_YAXIS; ///< Vector representing the negative Y axis
- static const Vector2 ZERO; ///< (0.0f, 0.0f)
+ static const Vector2 ONE; ///< (1.0f,1.0f)
+ static const Vector2 XAXIS; ///< Vector representing the X axis
+ static const Vector2 YAXIS; ///< Vector representing the Y axis
+ static const Vector2 NEGATIVE_XAXIS; ///< Vector representing the negative X axis
+ static const Vector2 NEGATIVE_YAXIS; ///< Vector representing the negative Y axis
+ static const Vector2 ZERO; ///< (0.0f, 0.0f)
-// API
+ // API
/**
* @brief Assignment operator.
return Vector2(x / rhs, y / rhs);
}
-
/**
* @brief Division assignment operator.
*
*/
const float& operator[](const uint32_t index) const
{
- DALI_ASSERT_ALWAYS( index < 2 && "Vector element index out of bounds" );
+ DALI_ASSERT_ALWAYS(index < 2 && "Vector element index out of bounds");
return AsFloat()[index];
}
*/
float& operator[](const uint32_t index)
{
- DALI_ASSERT_ALWAYS( index < 2 && "Vector element index out of bounds" );
+ DALI_ASSERT_ALWAYS(index < 2 && "Vector element index out of bounds");
return AsFloat()[index];
}
* @param[in] min The minimum vector
* @param[in] max The maximum vector
*/
- void Clamp( const Vector2& min, const Vector2& max );
+ void Clamp(const Vector2& min, const Vector2& max);
/**
* @brief Returns the contents of the vector as an array of 2 floats.
* @return The vector contents as an array of 2 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- const float* AsFloat() const {return &x;}
+ const float* AsFloat() const
+ {
+ return &x;
+ }
/**
* @brief Returns the contents of the vector as an array of 2 floats.
* @return The vector contents as an array of 2 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- float* AsFloat() {return &x;}
+ float* AsFloat()
+ {
+ return &x;
+ }
public:
-
- Vector2( const Vector2& ) = default; ///< Default copy constructor
- Vector2( Vector2&& ) = default; ///< Default move constructor
- Vector2& operator=( const Vector2& ) = default; ///< Default copy assignment operator
- Vector2& operator=( Vector2&& ) = default; ///< Default move assignment operator
+ Vector2(const Vector2&) = default; ///< Default copy constructor
+ Vector2(Vector2&&) = default; ///< Default move constructor
+ Vector2& operator=(const Vector2&) = default; ///< Default copy assignment operator
+ Vector2& operator=(Vector2&&) = default; ///< Default move assignment operator
public: // Data
-
// NOTE
// (x width) and (y height) must be consecutive in memory.
// No other data must be added before (x width) member.
float y; ///< y component
float height; ///< height
};
-
};
/**
* @brief Size is an alias of Dali::Vector2.
* @SINCE_1_0.0
*/
-typedef Vector2 Size;
+using Size = Vector2;
/**
* @brief Print a Vector2.
* @param[in] vector The vector to print
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Vector2& vector);
+DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Vector2& vector);
/**
* @brief Returns a vector with components set to the minimum of the corresponding component in a and b.
* @param[in] b A vector
* @return A vector containing the minimum of each component from a and b
*/
-inline Vector2 Min( const Vector2& a, const Vector2& b )
+inline Vector2 Min(const Vector2& a, const Vector2& b)
{
- return Vector2( a.x < b.x ? a.x : b.x , a.y < b.y ? a.y : b.y );
+ return Vector2(a.x < b.x ? a.x : b.x, a.y < b.y ? a.y : b.y);
}
/**
* @param[in] b A vector
* @return A vector containing the maximum of each component from a and b
*/
-inline Vector2 Max( const Vector2& a, const Vector2& b )
+inline Vector2 Max(const Vector2& a, const Vector2& b)
{
- return Vector2( a.x > b.x ? a.x : b.x , a.y > b.y ? a.y : b.y );
+ return Vector2(a.x > b.x ? a.x : b.x, a.y > b.y ? a.y : b.y);
}
/**
* @param[in] max The maximum value
* @return A vector containing the clamped components of v
*/
-DALI_CORE_API Vector2 Clamp( const Vector2& v, const float& min, const float& max );
+DALI_CORE_API Vector2 Clamp(const Vector2& v, const float& min, const float& max);
// Allow Vector2 to be treated as a POD type
-template <> struct TypeTraits< Vector2 > : public BasicTypes< Vector2 > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Vector2> : public BasicTypes<Vector2>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/math/vector3.h>
#include <dali/public-api/math/quaternion.h>
+#include <dali/public-api/math/vector3.h>
// EXTERNAL INCLUDES
#include <math.h>
#include <ostream>
// INTERNAL INCLUDES
+#include <dali/internal/render/common/performance-monitor.h>
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/math-utils.h>
-#include <dali/internal/render/common/performance-monitor.h>
namespace Dali
{
const Vector3 Vector3::NEGATIVE_ZAXIS(0.0f, 0.0f, -1.0f);
const Vector3 Vector3::ZERO(0.0f, 0.0f, 0.0f);
-Vector3::Vector3( const Vector2& vec2 )
+Vector3::Vector3(const Vector2& vec2)
: x(vec2.x),
y(vec2.y),
z(0.0f)
{
}
-Vector3::Vector3( const Vector4& vec4 )
+Vector3::Vector3(const Vector4& vec4)
: x(vec4.x),
y(vec4.y),
z(vec4.z)
// nVidia SDK implementation
Vector3 qvec(rhs.mVector.x, rhs.mVector.y, rhs.mVector.z);
- Vector3 uv( (qvec.y * z) - (qvec.z * y),
- (qvec.z * x) - (qvec.x * z),
- (qvec.x * y) - (qvec.y * x) );
+ Vector3 uv((qvec.y * z) - (qvec.z * y),
+ (qvec.z * x) - (qvec.x * z),
+ (qvec.x * y) - (qvec.y * x));
- Vector3 uuv( (qvec.y * uv.z) - (qvec.z * uv.y),
- (qvec.z * uv.x) - (qvec.x * uv.z),
- (qvec.x * uv.y) - (qvec.y * uv.x) );
+ Vector3 uuv((qvec.y * uv.z) - (qvec.z * uv.y),
+ (qvec.z * uv.x) - (qvec.x * uv.z),
+ (qvec.x * uv.y) - (qvec.y * uv.x));
uv *= rhs.mVector.w;
bool Vector3::operator==(const Vector3& rhs) const
{
- if (fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x) )
+ if(fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x))
{
return false;
}
- if (fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y) )
+ if(fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y))
{
return false;
}
- if (fabsf(z - rhs.z) > GetRangedEpsilon(z, rhs.z) )
+ if(fabsf(z - rhs.z) > GetRangedEpsilon(z, rhs.z))
{
return false;
}
return true;
}
-float Vector3::Dot(const Vector3 &other) const
+float Vector3::Dot(const Vector3& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
return x * other.x + y * other.y + z * other.z;
}
-Vector3 Vector3::Cross(const Vector3 &other) const
+Vector3 Vector3::Cross(const Vector3& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,6);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 6);
- return Vector3( (y * other.z) - (z * other.y),
- (z * other.x) - (x * other.z),
- (x * other.y) - (y * other.x));
+ return Vector3((y * other.z) - (z * other.y),
+ (z * other.x) - (x * other.z),
+ (x * other.y) - (y * other.x));
}
float Vector3::Length() const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
- return sqrtf(x*x + y*y + z*z);
+ return sqrtf(x * x + y * y + z * z);
}
float Vector3::LengthSquared() const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
- return x*x + y*y + z*z;
+ return x * x + y * y + z * z;
}
void Vector3::Normalize()
{
float length = Length();
- if( ! EqualsZero(length) )
+ if(!EqualsZero(length))
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
const float inverseLength = 1.0f / length;
x *= inverseLength;
}
}
-void Vector3::Clamp( const Vector3& min, const Vector3& max )
+void Vector3::Clamp(const Vector3& min, const Vector3& max)
{
- Dali::ClampInPlace<float>( x, min.x, max.x );
- Dali::ClampInPlace<float>( y, min.y, max.y );
- Dali::ClampInPlace<float>( z, min.z, max.z );
+ Dali::ClampInPlace<float>(x, min.x, max.x);
+ Dali::ClampInPlace<float>(y, min.y, max.y);
+ Dali::ClampInPlace<float>(z, min.z, max.z);
}
-std::ostream& operator<< (std::ostream& o, const Vector3& vector)
+std::ostream& operator<<(std::ostream& o, const Vector3& vector)
{
return o << "[" << vector.x << ", " << vector.y << ", " << vector.z << "]";
}
-Vector3 Clamp( const Vector3& v, const float& min, const float& max )
+Vector3 Clamp(const Vector3& v, const float& min, const float& max)
{
- Vector3 result( v );
- result.Clamp( Vector3( min, min, min ) , Vector3( max, max, max ) );
+ Vector3 result(v);
+ result.Clamp(Vector3(min, min, min), Vector3(max, max, max));
return result;
}
*/
struct DALI_CORE_API Vector3
{
-// Construction
+ // Construction
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param[in] vec2 Vector2 to create this vector from
*/
- explicit Vector3( const Vector2& vec2 );
+ explicit Vector3(const Vector2& vec2);
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param[in] vec4 Vector4 to create this vector from
*/
- explicit Vector3( const Vector4& vec4 );
+ explicit Vector3(const Vector4& vec4);
-// Constants
+ // Constants
- static const Vector3 ONE; ///< (1.0f,1.0f,1.0f)
- static const Vector3 XAXIS; ///< Vector representing the X axis
- static const Vector3 YAXIS; ///< Vector representing the Y axis
- static const Vector3 ZAXIS; ///< Vector representing the Z axis
- static const Vector3 NEGATIVE_XAXIS; ///< Vector representing the negative X axis
- static const Vector3 NEGATIVE_YAXIS; ///< Vector representing the negative Y axis
- static const Vector3 NEGATIVE_ZAXIS; ///< Vector representing the negative Z axis
- static const Vector3 ZERO; ///< (0.0f, 0.0f, 0.0f)
+ static const Vector3 ONE; ///< (1.0f,1.0f,1.0f)
+ static const Vector3 XAXIS; ///< Vector representing the X axis
+ static const Vector3 YAXIS; ///< Vector representing the Y axis
+ static const Vector3 ZAXIS; ///< Vector representing the Z axis
+ static const Vector3 NEGATIVE_XAXIS; ///< Vector representing the negative X axis
+ static const Vector3 NEGATIVE_YAXIS; ///< Vector representing the negative Y axis
+ static const Vector3 NEGATIVE_ZAXIS; ///< Vector representing the negative Z axis
+ static const Vector3 ZERO; ///< (0.0f, 0.0f, 0.0f)
-// API
+ // API
/**
* @brief Assignment operator.
*/
const float& operator[](const uint32_t index) const
{
- DALI_ASSERT_ALWAYS( index < 3 && "Vector element index out of bounds" );
+ DALI_ASSERT_ALWAYS(index < 3 && "Vector element index out of bounds");
return AsFloat()[index];
}
*/
float& operator[](const uint32_t index)
{
- DALI_ASSERT_ALWAYS( index < 3 && "Vector element index out of bounds" );
+ DALI_ASSERT_ALWAYS(index < 3 && "Vector element index out of bounds");
return AsFloat()[index];
}
* @param[in] min The minimum vector
* @param[in] max The maximum vector
*/
- void Clamp( const Vector3& min, const Vector3& max );
+ void Clamp(const Vector3& min, const Vector3& max);
/**
* @brief Returns the contents of the vector as an array of 3 floats.
* @return The vector contents as an array of 3 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- const float* AsFloat() const {return &x;}
+ const float* AsFloat() const
+ {
+ return &x;
+ }
/**
* @brief Returns the contents of the vector as an array of 3 floats.
* @return The vector contents as an array of 3 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- float* AsFloat() {return &x;}
+ float* AsFloat()
+ {
+ return &x;
+ }
/**
* @brief Returns the x & y components (or width & height, or r & g) as a Vector2.
* @return The partial vector contents as Vector2 (x,y)
* @note inlined for performance reasons (generates less code than a function call)
*/
- const Vector2& GetVectorXY() const {return reinterpret_cast<const Vector2&>(x);}
+ const Vector2& GetVectorXY() const
+ {
+ return reinterpret_cast<const Vector2&>(x);
+ }
/**
* @brief Returns the x & y components (or width & height, or r & g) as a Vector2.
* @return The partial vector contents as Vector2 (x,y)
* @note inlined for performance reasons (generates less code than a function call)
*/
- Vector2& GetVectorXY() {return reinterpret_cast<Vector2&>(x);}
+ Vector2& GetVectorXY()
+ {
+ return reinterpret_cast<Vector2&>(x);
+ }
/**
* @brief Returns the y & z components (or height & depth, or g & b) as a Vector2.
* @return The partial vector contents as Vector2 (y,z)
* @note inlined for performance reasons (generates less code than a function call)
*/
- const Vector2& GetVectorYZ() const {return reinterpret_cast<const Vector2&>(y);}
+ const Vector2& GetVectorYZ() const
+ {
+ return reinterpret_cast<const Vector2&>(y);
+ }
/**
* @brief Returns the y & z components (or height & depth, or g & b) as a Vector2.
* @return The partial vector contents as Vector2 (y,z)
* @note inlined for performance reasons (generates less code than a function call)
*/
- Vector2& GetVectorYZ() {return reinterpret_cast<Vector2&>(y);}
+ Vector2& GetVectorYZ()
+ {
+ return reinterpret_cast<Vector2&>(y);
+ }
-// Data
+ // Data
// NOTE
// (x width r), (y height g), (z depth b) must be consecutive in memory.
// No virtual methods must be added to this struct.
union
{
- float x; ///< x component
- float width; ///< width component
- float r; ///< red component
+ float x; ///< x component
+ float width; ///< width component
+ float r; ///< red component
};
union
{
};
union
{
- float z; ///< z component
- float depth; ///< depth component
- float b; ///< blue component
+ float z; ///< z component
+ float depth; ///< depth component
+ float b; ///< blue component
};
public:
-
- Vector3( const Vector3& ) = default; ///< Default copy constructor
- Vector3( Vector3&& ) = default; ///< Default move constructor
- Vector3& operator=( const Vector3& ) = default; ///< Default copy assignment operator
- Vector3& operator=( Vector3&& ) = default; ///< Default move assignment operator
+ Vector3(const Vector3&) = default; ///< Default copy constructor
+ Vector3(Vector3&&) = default; ///< Default move constructor
+ Vector3& operator=(const Vector3&) = default; ///< Default copy assignment operator
+ Vector3& operator=(Vector3&&) = default; ///< Default move assignment operator
};
/**
* @param[in] vector The vector to print
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<< (std::ostream& o, const Vector3& vector);
+DALI_CORE_API std::ostream& operator<<(std::ostream& o, const Vector3& vector);
/**
* @brief Returns a vector with components set to the minimum of the corresponding component in a and b.
* @param[in] b A vector
* @return A vector containing the minimum of each component from a and b
*/
-inline Vector3 Min( const Vector3& a, const Vector3& b )
+inline Vector3 Min(const Vector3& a, const Vector3& b)
{
- return Vector3( a.x < b.x ? a.x : b.x ,
- a.y < b.y ? a.y : b.y,
- a.z < b.z ? a.z : b.z );
+ return Vector3(a.x < b.x ? a.x : b.x,
+ a.y < b.y ? a.y : b.y,
+ a.z < b.z ? a.z : b.z);
}
/**
* @param[in] b A vector
* @return A vector containing the maximum of each component from a and b
*/
-inline Vector3 Max( const Vector3& a, const Vector3& b )
+inline Vector3 Max(const Vector3& a, const Vector3& b)
{
- return Vector3( a.x > b.x ? a.x : b.x,
- a.y > b.y ? a.y : b.y,
- a.z > b.z ? a.z : b.z );
+ return Vector3(a.x > b.x ? a.x : b.x,
+ a.y > b.y ? a.y : b.y,
+ a.z > b.z ? a.z : b.z);
}
/**
* @param[in] max The maximum value
* @return A vector containing the clamped components of v
*/
-DALI_CORE_API Vector3 Clamp( const Vector3& v, const float& min, const float& max );
+DALI_CORE_API Vector3 Clamp(const Vector3& v, const float& min, const float& max);
// Allow Vector3 to be treated as a POD type
-template <> struct TypeTraits< Vector3 > : public BasicTypes< Vector3 > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Vector3> : public BasicTypes<Vector3>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 <ostream>
// INTERNAL INCLUDES
+#include <dali/internal/render/common/performance-monitor.h>
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/math/math-utils.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
-#include <dali/public-api/math/math-utils.h>
-#include <dali/internal/render/common/performance-monitor.h>
namespace Dali
{
-
using Internal::PerformanceMonitor;
const Vector4 Vector4::ONE(1.0f, 1.0f, 1.0f, 1.0f);
const Vector4 Vector4::ZAXIS(0.0f, 0.0f, 1.0f, 0.0f);
const Vector4 Vector4::ZERO(0.0f, 0.0f, 0.0f, 0.0f);
-Vector4::Vector4( const Vector2& vec2 )
+Vector4::Vector4(const Vector2& vec2)
: x(vec2.x),
y(vec2.y),
z(0.0f),
{
}
-Vector4::Vector4( const Vector3& vec3 )
+Vector4::Vector4(const Vector3& vec3)
: x(vec3.x),
y(vec3.y),
z(vec3.z),
{
}
-Vector4& Vector4::operator=(const Vector2& vec2 )
+Vector4& Vector4::operator=(const Vector2& vec2)
{
x = vec2.x;
y = vec2.y;
return *this;
}
-Vector4& Vector4::operator=(const Vector3& vec3 )
+Vector4& Vector4::operator=(const Vector3& vec3)
{
x = vec3.x;
y = vec3.y;
return *this;
}
-
bool Vector4::operator==(const Vector4& rhs) const
{
- if (fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x) )
+ if(fabsf(x - rhs.x) > GetRangedEpsilon(x, rhs.x))
{
return false;
}
- if (fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y) )
+ if(fabsf(y - rhs.y) > GetRangedEpsilon(y, rhs.y))
{
return false;
}
- if (fabsf(z - rhs.z) > GetRangedEpsilon(z, rhs.z) )
+ if(fabsf(z - rhs.z) > GetRangedEpsilon(z, rhs.z))
{
return false;
}
- if (fabsf(w - rhs.w) > GetRangedEpsilon(w, rhs.w) )
+ if(fabsf(w - rhs.w) > GetRangedEpsilon(w, rhs.w))
{
return false;
}
return true;
}
-float Vector4::Dot(const Vector3 &other) const
+float Vector4::Dot(const Vector3& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
return x * other.x + y * other.y + z * other.z;
}
-float Vector4::Dot(const Vector4 &other) const
+float Vector4::Dot(const Vector4& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
return x * other.x + y * other.y + z * other.z;
}
-float Vector4::Dot4(const Vector4 &other) const
+float Vector4::Dot4(const Vector4& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,4);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 4);
return x * other.x + y * other.y + z * other.z + w * other.w;
}
-Vector4 Vector4::Cross(const Vector4 &other) const
+Vector4 Vector4::Cross(const Vector4& other) const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,6);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 6);
- return Vector4( (y * other.z) - (z * other.y),
- (z * other.x) - (x * other.z),
- (x * other.y) - (y * other.x),
- 0.0f);
+ return Vector4((y * other.z) - (z * other.y),
+ (z * other.x) - (x * other.z),
+ (x * other.y) - (y * other.x),
+ 0.0f);
}
// Will always return positive square root
float Vector4::Length() const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
- return sqrtf(x*x + y*y + z*z);
+ return sqrtf(x * x + y * y + z * z);
}
float Vector4::LengthSquared() const
{
- MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY,3);
+ MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
- return x*x + y*y + z*z;
+ return x * x + y * y + z * z;
}
void Vector4::Normalize()
const float length = Length();
// In the case where the length is exactly zero, the vector cannot be normalized.
- if ( ! EqualsZero( length ) )
+ if(!EqualsZero(length))
{
MATH_INCREASE_BY(PerformanceMonitor::FLOAT_POINT_MULTIPLY, 3);
}
}
-void Vector4::Clamp( const Vector4& min, const Vector4& max )
+void Vector4::Clamp(const Vector4& min, const Vector4& max)
{
- Dali::ClampInPlace<float>( x, min.x, max.x );
- Dali::ClampInPlace<float>( y, min.y, max.y );
- Dali::ClampInPlace<float>( z, min.z, max.z );
- Dali::ClampInPlace<float>( w, min.w, max.w );
+ Dali::ClampInPlace<float>(x, min.x, max.x);
+ Dali::ClampInPlace<float>(y, min.y, max.y);
+ Dali::ClampInPlace<float>(z, min.z, max.z);
+ Dali::ClampInPlace<float>(w, min.w, max.w);
}
-std::ostream& operator<< (std::ostream& o, const Vector4& vector)
+std::ostream& operator<<(std::ostream& o, const Vector4& vector)
{
return o << "[" << vector.x << ", " << vector.y << ", " << vector.z << ", " << vector.w << "]";
}
-Vector4 Clamp( const Vector4& v, const float& min, const float& max )
+Vector4 Clamp(const Vector4& v, const float& min, const float& max)
{
- Vector4 result( v );
- result.Clamp( Vector4( min, min, min, min ), Vector4( max, max, max, max) );
+ Vector4 result(v);
+ result.Clamp(Vector4(min, min, min, min), Vector4(max, max, max, max));
return result;
}
*/
struct DALI_CORE_API Vector4
{
-// NOTE
-// xrs, ygt, zbp and waq must be consecutive in memory.
-// No other data must be added before xrs member.
-// No virtual methods must be added to this struct.
+ // NOTE
+ // xrs, ygt, zbp and waq must be consecutive in memory.
+ // No other data must be added before xrs member.
+ // No virtual methods must be added to this struct.
-// Construction
+ // Construction
/**
* @brief Default constructor, initializes the vector to 0.
{
}
-
/**
* @brief Conversion constructor from an array of four floats.
*
* @SINCE_1_0.0
* @param[in] vec2 Vector2 to copy from, z and w are initialized to 0
*/
- explicit Vector4( const Vector2& vec2 );
+ explicit Vector4(const Vector2& vec2);
/**
* @brief Conversion constructor from Vector3.
* @SINCE_1_0.0
* @param[in] vec3 Vector3 to copy from, w is initialized to 0
*/
- explicit Vector4( const Vector3& vec3 );
+ explicit Vector4(const Vector3& vec3);
-// Constants
+ // Constants
static const Vector4 ONE; ///< (1.0f,1.0f,1.0f,1.0f)
static const Vector4 XAXIS; ///< (1.0f,0.0f,0.0f,0.0f)
static const Vector4 YAXIS; ///< (0.0f,1.0f,0.0f,0.0f)
static const Vector4 ZAXIS; ///< (0.0f,0.0f,1.0f,0.0f)
static const Vector4 ZERO; ///< (0.0f, 0.0f, 0.0f, 0.0f)
-// API
+ // API
/**
* @brief Assignment operator.
* @param[in] vec2 A reference to assign from
* @return Itself
*/
- Vector4& operator=(const Vector2& vec2 );
+ Vector4& operator=(const Vector2& vec2);
/**
* @brief Assignment operator.
* @param[in] vec3 A reference to assign from
* @return Itself
*/
- Vector4& operator=(const Vector3& vec3 );
+ Vector4& operator=(const Vector3& vec3);
/**
* @brief Addition operator.
* @param[in] rhs Vector to add
* @return A vector containing the result of the addition
*/
- Vector4 operator+(const Vector4 & rhs) const
+ Vector4 operator+(const Vector4& rhs) const
{
Vector4 temp(*this);
{
Vector4 temp(*this);
- temp-=rhs;
+ temp -= rhs;
return temp;
}
* @param[in] rhs The vector to divide
* @return A vector containing the result of the division
*/
- Vector4 operator/(const Vector4 & rhs) const
+ Vector4 operator/(const Vector4& rhs) const
{
Vector4 temp(*this);
* @param[in] rhs The vector to test against
* @return True if the vectors are equal
*/
- bool operator==(const Vector4 &rhs) const;
+ bool operator==(const Vector4& rhs) const;
/**
* @brief Inequality operator.
* @param[in] rhs The vector to test against
* @return True if the vectors are not equal
*/
- bool operator!=(const Vector4 &rhs) const
+ bool operator!=(const Vector4& rhs) const
{
return !(*this == rhs);
}
*/
const float& operator[](const uint32_t index) const
{
- DALI_ASSERT_ALWAYS( index < 4 && "Vector element index out of bounds" );
+ DALI_ASSERT_ALWAYS(index < 4 && "Vector element index out of bounds");
return AsFloat()[index];
}
*/
float& operator[](const uint32_t index)
{
- DALI_ASSERT_ALWAYS( index < 4 && "Vector element index out of bounds" );
+ DALI_ASSERT_ALWAYS(index < 4 && "Vector element index out of bounds");
return AsFloat()[index];
}
* @param[in] min The minimum vector
* @param[in] max The maximum vector
*/
- void Clamp( const Vector4& min, const Vector4& max );
+ void Clamp(const Vector4& min, const Vector4& max);
/**
* @brief Returns the contents of the vector as an array of 4 floats.
* @return The vector contents as an array of 4 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- const float* AsFloat() const {return &x;}
+ const float* AsFloat() const
+ {
+ return &x;
+ }
/**
* @brief Returns the contents of the vector as an array of 4 floats.
* @return The vector contents as an array of 4 floats
* @note inlined for performance reasons (generates less code than a function call)
*/
- float* AsFloat() {return &x;}
+ float* AsFloat()
+ {
+ return &x;
+ }
-// Data
+ // Data
// NOTE
// xrs, ygt, zbp and waq must be consecutive in memory.
};
public:
-
- Vector4( const Vector4& ) = default; ///< Default copy constructor
- Vector4( Vector4&& ) = default; ///< Default move constructor
- Vector4& operator=( const Vector4& ) = default; ///< Default copy assignment operator
- Vector4& operator=( Vector4&& ) = default; ///< Default move assignment operator
+ Vector4(const Vector4&) = default; ///< Default copy constructor
+ Vector4(Vector4&&) = default; ///< Default move constructor
+ Vector4& operator=(const Vector4&) = default; ///< Default copy assignment operator
+ Vector4& operator=(Vector4&&) = default; ///< Default move assignment operator
};
/**
* @param[in] b A vector
* @return A vector containing the minimum of each component from a and b
*/
-inline Vector4 Min( const Vector4& a, const Vector4& b )
+inline Vector4 Min(const Vector4& a, const Vector4& b)
{
- return Vector4( a.x < b.x ? a.x : b.x,
- a.y < b.y ? a.y : b.y,
- a.z < b.z ? a.z : b.z,
- a.w < b.w ? a.w : b.w );
+ return Vector4(a.x < b.x ? a.x : b.x,
+ a.y < b.y ? a.y : b.y,
+ a.z < b.z ? a.z : b.z,
+ a.w < b.w ? a.w : b.w);
}
/**
* @param[in] b A vector
* @return A vector containing the maximum of each component from a and b
*/
-inline Vector4 Max( const Vector4& a, const Vector4& b )
+inline Vector4 Max(const Vector4& a, const Vector4& b)
{
- return Vector4( a.x > b.x ? a.x : b.x,
- a.y > b.y ? a.y : b.y,
- a.z > b.z ? a.z : b.z,
- a.w > b.w ? a.w : b.w );
+ return Vector4(a.x > b.x ? a.x : b.x,
+ a.y > b.y ? a.y : b.y,
+ a.z > b.z ? a.z : b.z,
+ a.w > b.w ? a.w : b.w);
}
/**
* @param[in] max The maximum value
* @return A vector containing the clamped components of v
*/
-DALI_CORE_API Vector4 Clamp( const Vector4& v, const float& min, const float& max );
+DALI_CORE_API Vector4 Clamp(const Vector4& v, const float& min, const float& max);
// Allow Vector4 to be treated as a POD type
-template <> struct TypeTraits< Vector4 > : public BasicTypes< Vector4 > { enum { IS_TRIVIAL_TYPE = true }; };
+template<>
+struct TypeTraits<Vector4> : public BasicTypes<Vector4>
+{
+ enum
+ {
+ IS_TRIVIAL_TYPE = true
+ };
+};
/**
* @}
* @brief Typedef for a viewport ( a rectangle representing a screen area ).
* @SINCE_1_0.0
*/
-typedef Rect<int32_t> Viewport;
+using Viewport = Rect<int32_t>;
/**
* @}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
Any::Any()
-: mContainer( NULL )
+: mContainer(nullptr)
{
}
{
// Call the implementation deletion function, which will invalidate mContainer
- if ( NULL != mContainer )
+ if(nullptr != mContainer)
{
- mContainer->mDeleteFunc( mContainer );
- mContainer = NULL;
+ mContainer->mDeleteFunc(mContainer);
+ mContainer = nullptr;
}
}
-Any& Any::operator=( const Any& any )
+Any& Any::operator=(const Any& any)
{
- if( &any != this )
+ if(&any != this)
{
- if( NULL == any.mContainer )
+ if(nullptr == any.mContainer)
{
delete mContainer;
- mContainer = NULL;
+ mContainer = nullptr;
}
else
{
AnyContainerBase* tmp = mContainer;
- if( NULL != mContainer )
+ if(nullptr != mContainer)
{
// Check if two Any types have the same type. Avoids assignments of values with different types.
- if( mContainer->GetType() != any.GetType() )
+ if(mContainer->GetType() != any.GetType())
{
- AssertAlways( "Any::operator=( const Any& Any ). Trying to assign two values with different types." );
+ AssertAlways("Any::operator=( const Any& Any ). Trying to assign two values with different types.");
}
}
// Clone the correct templated object
- mContainer = any.mContainer->mCloneFunc( *any.mContainer );
+ mContainer = any.mContainer->mCloneFunc(*any.mContainer);
// Deletes previous container.
delete tmp;
const std::type_info& Any::GetType() const
{
- return mContainer ? mContainer->GetType() : typeid( void );
+ return mContainer ? mContainer->GetType() : typeid(void);
}
-void Any::AssertAlways( const char* assertMessage )
+void Any::AssertAlways(const char* assertMessage)
{
- DALI_LOG_ERROR_NOFN( assertMessage );
- throw Dali::DaliException( assertMessage, "" );
+ DALI_LOG_ERROR_NOFN(assertMessage);
+ throw Dali::DaliException(assertMessage, "");
}
-
} //namespace Dali
#define DALI_ANY_TYPE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <typeinfo> // operator typeid
-#include <cstddef> // NULL
+#include <cstddef> // NULL
+#include <typeinfo> // operator typeid
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
* @SINCE_1_0.0
* @param[in] assertMessage Assert message to report
*/
- DALI_CORE_API static void AssertAlways( const char* assertMessage );
+ DALI_CORE_API static void AssertAlways(const char* assertMessage);
/**
* @brief Constructs a Any type with the given value.
* @param[in] value The given value
*/
template<typename Type>
- Any( const Type& value )
- : mContainer( new AnyContainerImpl<Type>( value ) )
+ Any(const Type& value)
+ : mContainer(new AnyContainerImpl<Type>(value))
{
}
* @SINCE_1_0.0
* @param[in] any Any to be copied
*/
- Any( const Any& any )
+ Any(const Any& any)
{
// If container isn't empty then copy the container?
- if ( NULL != any.mContainer )
+ if(nullptr != any.mContainer)
{
- mContainer = any.mContainer->mCloneFunc( *any.mContainer );
+ mContainer = any.mContainer->mCloneFunc(*any.mContainer);
}
else
{
// Otherwise mark new container as empty
- mContainer = NULL;
+ mContainer = nullptr;
}
}
*
*/
template<typename Type>
- Any& operator=( const Type& value )
+ Any& operator=(const Type& value)
{
// If the container is empty then assign the new value
- if ( NULL == mContainer )
+ if(nullptr == mContainer)
{
- mContainer = new AnyContainerImpl< Type >( value );
+ mContainer = new AnyContainerImpl<Type>(value);
}
else
{
// Check to see if this type is compatible with current container?
- if ( mContainer->GetType() == typeid( Type ) )
+ if(mContainer->GetType() == typeid(Type))
{
// Same type so just set the new value
- static_cast< AnyContainerImpl< Type >* >( mContainer )->SetValue( value );
+ static_cast<AnyContainerImpl<Type>*>(mContainer)->SetValue(value);
}
else
{
// Incompatible types, so delete old container and assign a new one with this type and value
- mContainer->mDeleteFunc( mContainer );
- mContainer = new AnyContainerImpl< Type >( value );
+ mContainer->mDeleteFunc(mContainer);
+ mContainer = new AnyContainerImpl<Type>(value);
}
}
return *this;
* @exception DaliException If parameter any is of a different type.
*
*/
- DALI_CORE_API Any& operator=( const Any& any );
+ DALI_CORE_API Any& operator=(const Any& any);
/**
* @brief Gets a value of type Type from container.
* @param[in] type destination of type Type to write to
*/
template<typename Type>
- void Get( Type& type ) const
+ void Get(Type& type) const
{
type = Get<Type>();
}
template<typename Type>
const Type& Get() const
{
- if ( NULL == mContainer )
+ if(nullptr == mContainer)
{
- AssertAlways( "Any::Get(). mContainer is NULL" );
+ AssertAlways("Any::Get(). mContainer is NULL");
}
- else if( mContainer->GetType() != typeid( Type ) ) // Check if the value has the same value than the Any type.
+ else if(mContainer->GetType() != typeid(Type)) // Check if the value has the same value than the Any type.
{
- AssertAlways( "Any::Get(). Trying to retrieve a value of a different type than the template one." );
+ AssertAlways("Any::Get(). Trying to retrieve a value of a different type than the template one.");
}
- return static_cast< AnyContainerImpl< Type >* >( mContainer )->GetValue();
+ return static_cast<AnyContainerImpl<Type>*>(mContainer)->GetValue();
}
/**
template<typename Type>
Type* GetPointer()
{
- if( NULL == mContainer )
+ if(nullptr == mContainer)
{
return NULL;
}
- // Check if the value has the same value than the Any type.
- if( mContainer->GetType() != typeid( Type ) )
+ // Check if the value has the same value than the Any type.
+ if(mContainer->GetType() != typeid(Type))
{
- AssertAlways( "Any::GetPointer(). Trying to retrieve a pointer to a value of a different type than the template one." );
+ AssertAlways("Any::GetPointer(). Trying to retrieve a pointer to a value of a different type than the template one.");
}
- return static_cast< AnyContainerImpl< Type >* >( mContainer )->GetPointerToValue();
+ return static_cast<AnyContainerImpl<Type>*>(mContainer)->GetPointerToValue();
}
/**
template<typename Type>
const Type* GetPointer() const
{
- if( NULL == mContainer )
+ if(nullptr == mContainer)
{
return NULL;
}
- // Check if the value has the same value than the Any type.
- if( mContainer->GetType() != typeid( Type ) )
+ // Check if the value has the same value than the Any type.
+ if(mContainer->GetType() != typeid(Type))
{
- AssertAlways( "Any::GetPointer(). Trying to retrieve a pointer to a value of a different type than the template one." );
+ AssertAlways("Any::GetPointer(). Trying to retrieve a pointer to a value of a different type than the template one.");
}
- return static_cast< AnyContainerImpl< Type >* >( mContainer )->GetPointerToValue();
+ return static_cast<AnyContainerImpl<Type>*>(mContainer)->GetPointerToValue();
}
/**
*/
bool Empty() const
{
- return ( NULL == mContainer ) ? true : false;
+ return (nullptr == mContainer) ? true : false;
}
- struct AnyContainerBase; // Forward declaration for typedef
- typedef AnyContainerBase* (*CloneFunc)( const AnyContainerBase& base );
- typedef void (*DeleteFunc)( const AnyContainerBase* base );
+ struct AnyContainerBase; // Forward declaration for typedef
+ using CloneFunc = AnyContainerBase* (*)(const AnyContainerBase&);
+
+ using DeleteFunc = void (*)(const AnyContainerBase*);
/**
* @brief Base container to hold type for match verification and instance cloning function.
* @param[in] cloneFunc Cloning function to replicate this container type
* @param[in] deleteFunc Deleting function to destroy this container type
*/
- AnyContainerBase( const std::type_info& type, CloneFunc cloneFunc, DeleteFunc deleteFunc )
- : mType( type ),
- mCloneFunc( cloneFunc ),
- mDeleteFunc( deleteFunc )
- {}
+ AnyContainerBase(const std::type_info& type, CloneFunc cloneFunc, DeleteFunc deleteFunc)
+ : mType(type),
+ mCloneFunc(cloneFunc),
+ mDeleteFunc(deleteFunc)
+ {
+ }
/**
* @brief Gets the typeid of this container.
return mType;
}
- const::std::type_info& mType; // typeID
- CloneFunc mCloneFunc; // cloning function for this container
- DeleteFunc mDeleteFunc; // deleting function for this container
+ const ::std::type_info& mType; // typeID
+ CloneFunc mCloneFunc; // cloning function for this container
+ DeleteFunc mDeleteFunc; // deleting function for this container
};
-
/**
* @brief Templated Clone function from container base.
*
template<typename Type>
struct AnyContainerImplCloner
{
- static AnyContainerBase* Clone( const AnyContainerBase& base )
+ static AnyContainerBase* Clone(const AnyContainerBase& base)
{
- return new AnyContainerImpl< Type >( static_cast< AnyContainerImpl< Type > >( base ) );
+ return new AnyContainerImpl<Type>(static_cast<AnyContainerImpl<Type> >(base));
}
};
template<typename Type>
struct AnyContainerImplDelete
{
- static void Delete( const AnyContainerBase* base )
+ static void Delete(const AnyContainerBase* base)
{
- delete ( static_cast< const AnyContainerImpl< Type >* > ( base ) );
+ delete(static_cast<const AnyContainerImpl<Type>*>(base));
}
};
class AnyContainerImpl : public AnyContainerBase
{
public:
-
/**
* @brief Constructor to create container holding value of type Type.
*
* @SINCE_1_0.0
* @param[in] value Value of Type
*/
- AnyContainerImpl( const Type& value )
- : AnyContainerBase( typeid( Type ),
- static_cast< CloneFunc >( &AnyContainerImplCloner< Type >::Clone ),
- static_cast< DeleteFunc >( &AnyContainerImplDelete< Type >::Delete ) ),
- mValue( value )
- {}
+ AnyContainerImpl(const Type& value)
+ : AnyContainerBase(typeid(Type),
+ static_cast<CloneFunc>(&AnyContainerImplCloner<Type>::Clone),
+ static_cast<DeleteFunc>(&AnyContainerImplDelete<Type>::Delete)),
+ mValue(value)
+ {
+ }
/**
* @brief Constructor to create new container of type from and existing container (cloning).
* @SINCE_1_0.0
* @param[in] base The reference to base container to copy from
*/
- AnyContainerImpl( const AnyContainerBase& base )
- : AnyContainerBase( typeid( Type ),
- static_cast< CloneFunc >( &AnyContainerImplCloner< Type >::Clone ),
- static_cast< DeleteFunc >( &AnyContainerImplDelete< Type >::Delete ) )
+ AnyContainerImpl(const AnyContainerBase& base)
+ : AnyContainerBase(typeid(Type),
+ static_cast<CloneFunc>(&AnyContainerImplCloner<Type>::Clone),
+ static_cast<DeleteFunc>(&AnyContainerImplDelete<Type>::Delete))
{
- mValue = static_cast< const AnyContainerImpl& >( base ).GetValue();
+ mValue = static_cast<const AnyContainerImpl&>(base).GetValue();
}
/**
* @SINCE_1_0.0
* @param[in] value Value of type Type
*/
- void SetValue( const Type& value )
+ void SetValue(const Type& value)
{
mValue = value;
}
*/
Type* GetPointerToValue()
{
- return static_cast< Type* >( &mValue );
+ return static_cast<Type*>(&mValue);
}
/**
*/
const Type* GetPointerToValue() const
{
- return static_cast< const Type* >( &mValue );
+ return static_cast<const Type*>(&mValue);
}
- private:
- Type mValue;
+ private:
+ Type mValue;
};
AnyContainerBase* mContainer;
-
};
/**
* @return Pointer to the Type held
*/
template<typename Type>
-inline Type* AnyCast( Any* any )
+inline Type* AnyCast(Any* any)
{
return any->GetPointer<Type>();
}
* @return const Pointer to the Type held
*/
template<typename Type>
-inline const Type* AnyCast( const Any* any )
+inline const Type* AnyCast(const Any* any)
{
return any->GetPointer<Type>();
}
* @return Type value of type Type
*/
template<typename Type>
-inline Type AnyCast( Any& any )
+inline Type AnyCast(Any& any)
{
return any.Get<Type>();
}
* @return Type value of type Type
*/
template<typename Type>
-inline Type AnyCast( const Any& any )
+inline Type AnyCast(const Any& any)
{
return any.Get<Type>();
}
* @return A reference to the Type value of type Type
*/
template<typename Type>
-inline Type& AnyCastReference( Any& any )
+inline Type& AnyCastReference(Any& any)
{
return any.Get<Type>();
}
* @return A const reference to the Type value of type Type
*/
template<typename Type>
-inline const Type& AnyCastReference( const Any& any )
+inline const Type& AnyCastReference(const Any& any)
{
return any.Get<Type>();
}
#include <dali/public-api/object/type-registry.h>
// INTERNAL INCLUDES
-#include <dali/internal/event/common/object-impl.h>
#include <dali/integration-api/debug.h>
+#include <dali/internal/event/common/object-impl.h>
namespace Dali
{
-
BaseHandle::BaseHandle(Dali::BaseObject* handle)
: mObjectHandle(handle)
{
BaseHandle& BaseHandle::operator=(const BaseHandle& rhs) = default;
-BaseHandle::BaseHandle( BaseHandle&& rhs ) = default;
+BaseHandle::BaseHandle(BaseHandle&& rhs) = default;
-BaseHandle& BaseHandle::operator=( BaseHandle&& rhs ) = default;
+BaseHandle& BaseHandle::operator=(BaseHandle&& rhs) = default;
bool BaseHandle::DoAction(const std::string& command, const Property::Map& attributes)
{
- return GetImplementation(*this).DoAction( command, attributes );
+ return GetImplementation(*this).DoAction(command, attributes);
}
const std::string& BaseHandle::GetTypeName() const
void BaseHandle::Reset()
{
- mObjectHandle = NULL;
+ mObjectHandle = nullptr;
}
BaseHandle::operator BaseHandle::BooleanType() const
{
- return mObjectHandle ? &BaseHandle::ThisIsSaferThanReturningVoidStar : NULL;
+ return mObjectHandle ? &BaseHandle::ThisIsSaferThanReturningVoidStar : nullptr;
}
bool BaseHandle::operator==(const BaseHandle& rhs) const
return mObjectHandle.Get();
}
-bool BaseHandle::DoConnectSignal( ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor )
+bool BaseHandle::DoConnectSignal(ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor)
{
- return GetImplementation(*this).DoConnectSignal( connectionTracker, signalName, functor );
+ return GetImplementation(*this).DoConnectSignal(connectionTracker, signalName, functor);
}
} // namespace Dali
class DALI_CORE_API BaseHandle
{
public:
-
/**
* @brief This constructor is used by Dali New() methods.
*
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- BaseHandle( BaseHandle&& rhs );
+ BaseHandle(BaseHandle&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- BaseHandle& operator=( BaseHandle&& rhs );
+ BaseHandle& operator=(BaseHandle&& rhs);
/**
* @brief Connects a void() functor to a specified signal.
* @return True if the signal was available
* @pre The signal must be available in this object.
*/
- template <class T>
- bool ConnectSignal( ConnectionTrackerInterface* connectionTracker, const std::string& signalName, const T& functor )
+ template<class T>
+ bool ConnectSignal(ConnectionTrackerInterface* connectionTracker, const std::string& signalName, const T& functor)
{
- return DoConnectSignal( connectionTracker, signalName, FunctorDelegate::New( functor ) );
+ return DoConnectSignal(connectionTracker, signalName, FunctorDelegate::New(functor));
}
/**
bool GetTypeInfo(Dali::TypeInfo& info) const;
public:
-
// BaseHandle accessors
/**
* @brief Pointer-to-member type.
* Objects can be implicitly converted to this for validity checks.
*/
- typedef void (BaseHandle::*BooleanType)() const;
+ using BooleanType = void (BaseHandle::*)() const;
/**
* @brief Converts an handle to a BooleanType.
Dali::RefObject* GetObjectPtr() const;
private:
-
/**
* @brief Not intended for application developers.
*
* @param[in] functorDelegate A newly allocated functor delegate (takes ownership)
* @return True if the signal was available
*/
- bool DoConnectSignal( ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functorDelegate );
+ bool DoConnectSignal(ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functorDelegate);
protected:
-
/**
* @brief Used by the safe bool idiom.
*
* in a boolean context without the usual harmful side effects.
* @SINCE_1_0.0
*/
- void ThisIsSaferThanReturningVoidStar() const {}
+ void ThisIsSaferThanReturningVoidStar() const
+ {
+ }
private:
-
IntrusivePtr<Dali::RefObject> mObjectHandle; ///< Object this handle points at.
-
};
/**
* @return Handle pointer to either a valid deriving handle or an uninitialized handle
* @pre The BaseHandle has been initialized.
*/
-template< class T >
-inline T DownCast( BaseHandle handle )
+template<class T>
+inline T DownCast(BaseHandle handle)
{
- return T::DownCast( handle );
+ return T::DownCast(handle);
}
// See also BaseHandle::BooleanType() conversion
* @param[in] rhs A reference to compare to
* @return True if the handle handles point to the same Dali resource, or if both are NULL
*/
-template <typename T>
+template<typename T>
inline bool operator==(const BaseHandle& lhs, const T& rhs)
{
// We depart from the safe bool idiom to allow Dali::BaseHandle derived classes to be compared
* @param[in] rhs A reference to compare to
* @return True if the handle handles point to the different Dali resources
*/
-template <typename T>
+template<typename T>
inline bool operator!=(const BaseHandle& lhs, const T& rhs)
{
// We depart from the safe bool idiom to allow Dali::BaseHandle derived classes to be compared
#include <dali/public-api/object/base-object.h>
// INTERNAL INCLUDES
-#include <dali/public-api/object/type-registry.h>
#include <dali/integration-api/debug.h>
+#include <dali/internal/event/common/base-object-impl.h>
#include <dali/internal/event/common/object-registry-impl.h>
#include <dali/internal/event/common/stage-impl.h>
-#include <dali/internal/event/common/type-registry-impl.h>
#include <dali/internal/event/common/thread-local-storage.h>
-#include <dali/internal/event/common/base-object-impl.h>
+#include <dali/internal/event/common/type-registry-impl.h>
+#include <dali/public-api/object/type-registry.h>
namespace Dali
{
-
BaseObject::BaseObject()
-: mImpl( new Impl( *this ) )
+: mImpl(new Impl(*this))
{
}
void BaseObject::RegisterObject()
{
Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
- if ( tls )
+ if(tls)
{
- tls->GetEventThreadServices().RegisterObject( this );
+ tls->GetEventThreadServices().RegisterObject(this);
}
}
Internal::ThreadLocalStorage* tls = Internal::ThreadLocalStorage::GetInternal();
// Guard to allow handle destruction after Core has been destroyed
- if( tls )
+ if(tls)
{
- tls->GetEventThreadServices().UnregisterObject( this );
+ tls->GetEventThreadServices().UnregisterObject(this);
}
}
{
Dali::Internal::TypeRegistry* registry = Dali::Internal::TypeRegistry::Get();
- if( registry )
+ if(registry)
{
return registry->DoActionTo(this, actionName, attributes);
}
{
Dali::Internal::TypeRegistry* registry = Dali::Internal::TypeRegistry::Get();
- if( registry )
+ if(registry)
{
Internal::TypeRegistry::TypeInfoPointer typeInfo = registry->GetTypeInfo(this);
- if( typeInfo )
+ if(typeInfo)
{
return typeInfo->GetName();
}
}
// Return an empty string if type-name not found.
- DALI_LOG_WARNING( "TypeName Not Found\n" );
+ DALI_LOG_WARNING("TypeName Not Found\n");
static std::string empty;
return empty;
}
Internal::TypeRegistry::TypeInfoPointer info = registry->GetTypeInfo(this);
if(info)
{
- typeInfo = Dali::TypeInfo( info.Get() );
+ typeInfo = Dali::TypeInfo(info.Get());
return true;
}
else
}
}
-bool BaseObject::DoConnectSignal( ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor )
+bool BaseObject::DoConnectSignal(ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functor)
{
Dali::Internal::TypeRegistry* registry = Dali::Internal::TypeRegistry::Get();
- if( registry )
+ if(registry)
{
- return registry->ConnectSignal( this, connectionTracker, signalName, functor );
+ return registry->ConnectSignal(this, connectionTracker, signalName, functor);
}
return false;
}
} // namespace Dali
-
#include <memory>
// INTERNAL INCLUDES
-#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/property.h>
+#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/signals/functor-delegate.h>
namespace Dali
class DALI_CORE_API BaseObject : public Dali::RefObject
{
public:
-
/**
* @brief Connects a void() functor to a specified signal.
*
* @return True if the signal was available
* @pre The signal must be available in this object.
*/
- template <class T>
- bool ConnectSignal( ConnectionTrackerInterface* connectionTracker, const std::string& signalName, const T& functor )
+ template<class T>
+ bool ConnectSignal(ConnectionTrackerInterface* connectionTracker, const std::string& signalName, const T& functor)
{
- return DoConnectSignal( connectionTracker, signalName, FunctorDelegate::New( functor ) );
+ return DoConnectSignal(connectionTracker, signalName, FunctorDelegate::New(functor));
}
/**
bool GetTypeInfo(Dali::TypeInfo& info) const;
public: // Not intended for application developers
-
/**
* @brief Not intended for application developers.
*
* @param[in] functorDelegate A newly allocated functor delegate (takes ownership)
* @return True if the signal was available
*/
- bool DoConnectSignal( ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functorDelegate );
+ bool DoConnectSignal(ConnectionTrackerInterface* connectionTracker, const std::string& signalName, FunctorDelegate* functorDelegate);
protected:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @brief A reference counted object may only be deleted by calling Unreference().
* @SINCE_1_0.0
*/
- virtual ~BaseObject();
+ ~BaseObject() override;
/**
* @brief Registers the object as created with the Object registry.
// Not copyable or movable
- BaseObject(const BaseObject& rhs) = delete; ///< Deleted copy constructor
- BaseObject(BaseObject&& rhs) = delete; ///< Deleted move constructor
+ BaseObject(const BaseObject& rhs) = delete; ///< Deleted copy constructor
+ BaseObject(BaseObject&& rhs) = delete; ///< Deleted move constructor
BaseObject& operator=(const BaseObject& rhs) = delete; ///< Deleted copy assignment operator
- BaseObject& operator=(BaseObject&& rhs) = delete; ///< Deleted move assignment operator
+ BaseObject& operator=(BaseObject&& rhs) = delete; ///< Deleted move assignment operator
public:
-
class DALI_INTERNAL Impl;
private:
-
std::unique_ptr<Impl> mImpl;
};
*/
inline BaseObject& GetImplementation(Dali::BaseHandle& handle)
{
- DALI_ASSERT_ALWAYS( handle && "BaseObject handle is empty" );
+ DALI_ASSERT_ALWAYS(handle && "BaseObject handle is empty");
return handle.GetBaseObject();
}
*/
inline const BaseObject& GetImplementation(const Dali::BaseHandle& handle)
{
- DALI_ASSERT_ALWAYS( handle && "BaseObject handle is empty" );
+ DALI_ASSERT_ALWAYS(handle && "BaseObject handle is empty");
return handle.GetBaseObject();
}
*/
} // namespace Dali
-# endif // __DALI_BASE_OBJECT_H__
+#endif // __DALI_BASE_OBJECT_H__
#include <dali/public-api/object/handle.h>
// INTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
+#include <dali/internal/event/animation/constraint-impl.h>
+#include <dali/internal/event/common/object-impl.h>
#include <dali/public-api/animation/constraint.h>
#include <dali/public-api/object/property-conditions.h>
#include <dali/public-api/object/property-notification.h>
-#include <dali/internal/event/animation/constraint-impl.h>
-#include <dali/internal/event/common/object-impl.h>
-#include <dali/integration-api/debug.h>
namespace Dali
{
-
-
-Handle::Handle( Dali::Internal::Object* handle )
+Handle::Handle(Dali::Internal::Object* handle)
: BaseHandle(handle)
{
}
Handle Handle::New()
{
- return Handle( Internal::Object::New().Get() );
+ return Handle(Internal::Object::New().Get());
}
Handle::~Handle()
{
}
-Handle::Handle( const Handle& handle ) = default;
+Handle::Handle(const Handle& handle) = default;
-Handle& Handle::operator=( const Handle& rhs ) = default;
+Handle& Handle::operator=(const Handle& rhs) = default;
-Handle::Handle( Handle&& rhs ) = default;
+Handle::Handle(Handle&& rhs) = default;
-Handle& Handle::operator=( Handle&& rhs ) = default;
+Handle& Handle::operator=(Handle&& rhs) = default;
-Handle Handle::DownCast( BaseHandle handle )
+Handle Handle::DownCast(BaseHandle handle)
{
- return Handle( dynamic_cast<Dali::Internal::Object*>(handle.GetObjectPtr()) );
+ return Handle(dynamic_cast<Dali::Internal::Object*>(handle.GetObjectPtr()));
}
-bool Handle::Supports( Capability capability ) const
+bool Handle::Supports(Capability capability) const
{
- return GetImplementation(*this).Supports( capability );
+ return GetImplementation(*this).Supports(capability);
}
uint32_t Handle::GetPropertyCount() const
return GetImplementation(*this).GetPropertyCount();
}
-std::string Handle::GetPropertyName( Property::Index index ) const
+std::string Handle::GetPropertyName(Property::Index index) const
{
- return GetImplementation(*this).GetPropertyName( index );
+ return GetImplementation(*this).GetPropertyName(index);
}
-Property::Index Handle::GetPropertyIndex( Property::Key key ) const
+Property::Index Handle::GetPropertyIndex(Property::Key key) const
{
- return GetImplementation( *this ).GetPropertyIndex( key );
+ return GetImplementation(*this).GetPropertyIndex(key);
}
-bool Handle::IsPropertyWritable( Property::Index index ) const
+bool Handle::IsPropertyWritable(Property::Index index) const
{
- return GetImplementation(*this).IsPropertyWritable( index );
+ return GetImplementation(*this).IsPropertyWritable(index);
}
-bool Handle::IsPropertyAnimatable( Property::Index index ) const
+bool Handle::IsPropertyAnimatable(Property::Index index) const
{
- return GetImplementation(*this).IsPropertyAnimatable( index );
+ return GetImplementation(*this).IsPropertyAnimatable(index);
}
-bool Handle::IsPropertyAConstraintInput( Property::Index index ) const
+bool Handle::IsPropertyAConstraintInput(Property::Index index) const
{
- return GetImplementation(*this).IsPropertyAConstraintInput( index );
+ return GetImplementation(*this).IsPropertyAConstraintInput(index);
}
-Property::Type Handle::GetPropertyType( Property::Index index ) const
+Property::Type Handle::GetPropertyType(Property::Index index) const
{
- return GetImplementation(*this).GetPropertyType( index );
+ return GetImplementation(*this).GetPropertyType(index);
}
-void Handle::SetProperty( Property::Index index, const Property::Value& propertyValue )
+void Handle::SetProperty(Property::Index index, Property::Value propertyValue)
{
- GetImplementation(*this).SetProperty( index, propertyValue );
+ GetImplementation(*this).SetProperty(index, std::move(propertyValue));
}
-Property::Index Handle::RegisterProperty( const std::string& name, const Property::Value& propertyValue )
+Property::Index Handle::RegisterProperty(std::string name, Property::Value propertyValue)
{
- return GetImplementation(*this).RegisterProperty( name, propertyValue );
+ return GetImplementation(*this).RegisterProperty(std::move(name), std::move(propertyValue));
}
-Property::Index Handle::RegisterProperty( Property::Index key, const std::string& name, const Property::Value& propertyValue )
+Property::Index Handle::RegisterProperty(Property::Index key, std::string name, Property::Value propertyValue)
{
- return GetImplementation( *this ).RegisterProperty( name, key, propertyValue );
+ return GetImplementation(*this).RegisterProperty(std::move(name), key, std::move(propertyValue));
}
-Property::Index Handle::RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode )
+Property::Index Handle::RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode)
{
- return GetImplementation(*this).RegisterProperty( name, propertyValue, accessMode );
+ return GetImplementation(*this).RegisterProperty(std::move(name), std::move(propertyValue), accessMode);
}
-Property::Value Handle::GetProperty( Property::Index index ) const
+Property::Value Handle::GetProperty(Property::Index index) const
{
- return GetImplementation(*this).GetProperty( index );
+ return GetImplementation(*this).GetProperty(index);
}
-Property::Value Handle::GetCurrentProperty( Property::Index index ) const
+Property::Value Handle::GetCurrentProperty(Property::Index index) const
{
- return GetImplementation(*this).GetCurrentProperty( index );
+ return GetImplementation(*this).GetCurrentProperty(index);
}
-void Handle::SetProperties( const Property::Map& properties )
+void Handle::SetProperties(const Property::Map& properties)
{
- GetImplementation( *this ).SetProperties( properties );
+ GetImplementation(*this).SetProperties(properties);
}
-void Handle::GetProperties( Property::Map& properties )
+void Handle::GetProperties(Property::Map& properties)
{
- GetImplementation( *this ).GetProperties( properties );
+ GetImplementation(*this).GetProperties(properties);
}
-void Handle::GetPropertyIndices( Property::IndexContainer& indices ) const
+void Handle::GetPropertyIndices(Property::IndexContainer& indices) const
{
- GetImplementation(*this).GetPropertyIndices( indices );
+ GetImplementation(*this).GetPropertyIndices(indices);
}
-bool Handle::DoesCustomPropertyExist( Property::Index index )
+bool Handle::DoesCustomPropertyExist(Property::Index index)
{
- return GetImplementation( *this ).DoesCustomPropertyExist( index );
+ return GetImplementation(*this).DoesCustomPropertyExist(index);
}
-Dali::PropertyNotification Handle::AddPropertyNotification( Property::Index index,
- const PropertyCondition& condition )
+Dali::PropertyNotification Handle::AddPropertyNotification(Property::Index index,
+ const PropertyCondition& condition)
{
- return GetImplementation(*this).AddPropertyNotification( index, -1, condition );
+ return GetImplementation(*this).AddPropertyNotification(index, -1, condition);
}
-Dali::PropertyNotification Handle::AddPropertyNotification( Property::Index index,
- int componentIndex,
- const PropertyCondition& condition )
+Dali::PropertyNotification Handle::AddPropertyNotification(Property::Index index,
+ int componentIndex,
+ const PropertyCondition& condition)
{
- return GetImplementation(*this).AddPropertyNotification( index, componentIndex, condition );
+ return GetImplementation(*this).AddPropertyNotification(index, componentIndex, condition);
}
-void Handle::RemovePropertyNotification( Dali::PropertyNotification propertyNotification )
+void Handle::RemovePropertyNotification(Dali::PropertyNotification propertyNotification)
{
- GetImplementation(*this).RemovePropertyNotification( propertyNotification );
+ GetImplementation(*this).RemovePropertyNotification(propertyNotification);
}
void Handle::RemovePropertyNotifications()
GetImplementation(*this).RemoveConstraints();
}
-void Handle::RemoveConstraints( uint32_t tag )
+void Handle::RemoveConstraints(uint32_t tag)
{
- GetImplementation(*this).RemoveConstraints( tag );
+ GetImplementation(*this).RemoveConstraints(tag);
}
-IndirectValue Handle::operator[]( Property::Index index )
+IndirectValue Handle::operator[](Property::Index index)
{
// Will assert on access if handle is empty
return IndirectValue(*this, index);
}
-IndirectValue Handle::operator[]( const std::string& name )
+IndirectValue Handle::operator[](const std::string& name)
{
// Will assert immediately when GetPropertyIndex is called if handle is empty
return IndirectValue(*this, GetPropertyIndex(name));
Handle::PropertySetSignalType& Handle::PropertySetSignal()
{
- return GetImplementation( *this ).PropertySetSignal();
+ return GetImplementation(*this).PropertySetSignal();
}
-
namespace WeightObject
{
-
const Property::Index WEIGHT = PROPERTY_CUSTOM_START_INDEX;
Handle New()
{
Handle handle = Handle::New();
- handle.RegisterProperty( "weight", 0.0f );
+ handle.RegisterProperty("weight", 0.0f);
return handle;
}
*/
// EXTERNAL INCLUDES
-#include <string>
#include <cstdint> // uint32_t
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/object/indirect-value.h>
#include <dali/public-api/object/property-key.h>
+#include <dali/public-api/object/property-notification-declarations.h>
#include <dali/public-api/object/property-types.h>
#include <dali/public-api/object/property-value.h>
-#include <dali/public-api/object/property-notification-declarations.h>
#include <dali/public-api/object/ref-object.h>
#include <dali/public-api/signals/dali-signal.h>
-
namespace Dali
{
/**
class DALI_CORE_API Handle : public BaseHandle
{
public:
-
/**
* @brief Enumeration for Handle's capabilities that can be queried using Handle::Supports().
* @SINCE_1_0.0
/**
* @brief PropertySetSignal function prototype for signal handler. Called when a property is set on this object.
*/
- using PropertySetSignalType = Signal< void( Handle& handle, Property::Index index, Property::Value value ) >;
+ using PropertySetSignalType = Signal<void(Handle& handle, Property::Index index, Property::Value value)>;
public:
-
/**
* @brief This constructor is used by Dali New() methods.
*
* @SINCE_1_0.0
* @param[in] handle A pointer to a newly allocated Dali resource
*/
- Handle( Dali::Internal::Object* handle );
+ Handle(Dali::Internal::Object* handle);
/**
* @brief This constructor provides an uninitialized Dali::Handle.
* @tparam T The derived class to create
* @param[in] properties The properties to set
*/
- template< typename Type >
- static DALI_NO_EXPORT_API Type New( const Property::Map& properties )
+ template<typename Type>
+ static DALI_NO_EXPORT_API Type New(const Property::Map& properties)
{
Type handle = Type::New();
- handle.SetProperties( properties );
+ handle.SetProperties(properties);
return handle;
}
* @SINCE_1_0.0
* @param[in] handle A reference to the copied handle
*/
- Handle( const Handle& handle );
+ Handle(const Handle& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- Handle& operator=( const Handle& rhs );
+ Handle& operator=(const Handle& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Handle( Handle&& rhs );
+ Handle(Handle&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Handle& operator=( Handle&& rhs );
+ Handle& operator=(Handle&& rhs);
/**
* @brief Downcasts to a handle.
* @param[in] handle to An object
* @return handle or an uninitialized handle
*/
- static Handle DownCast( BaseHandle handle );
+ static Handle DownCast(BaseHandle handle);
/**
* @brief Queries whether an handle supports a given capability.
* @param[in] capability The queried capability
* @return True if the capability is supported
*/
- bool Supports( Capability capability ) const;
+ bool Supports(Capability capability) const;
// Properties
* @param[in] index The index of the property
* @return The name of the property
*/
- std::string GetPropertyName( Property::Index index ) const;
+ std::string GetPropertyName(Property::Index index) const;
/**
* @brief Query the index of a property using the given key.
* @return the matching property index of the key, or Property::INVALID_INDEX if no
* property matches the given key.
*/
- Property::Index GetPropertyIndex( Property::Key key ) const;
+ Property::Index GetPropertyIndex(Property::Key key) const;
/**
* @brief Queries whether a property can be set using SetProperty().
* @return True if the property is writable
* @pre Property::INVALID_INDEX < index.
*/
- bool IsPropertyWritable( Property::Index index ) const;
+ bool IsPropertyWritable(Property::Index index) const;
/**
* @brief Queries whether a writable property can be the target of an animation or constraint.
* @param[in] index The index of the property
* @return True if the property is animatable
*/
- bool IsPropertyAnimatable( Property::Index index ) const;
+ bool IsPropertyAnimatable(Property::Index index) const;
/**
* @brief Queries whether a property can be used as in input to a constraint.
* @param[in] index The index of the property
* @return True if the property can be used as a constraint input
*/
- bool IsPropertyAConstraintInput( Property::Index index ) const;
+ bool IsPropertyAConstraintInput(Property::Index index) const;
/**
* @brief Queries the type of a property.
* @param[in] index The index of the property
* @return The type of the property
*/
- Property::Type GetPropertyType( Property::Index index ) const;
+ Property::Type GetPropertyType(Property::Index index) const;
/**
* @brief Sets the value of an existing property.
* @param[in] propertyValue The new value of the property
* @pre The property types match i.e. propertyValue.GetType() is equal to GetPropertyType(index).
*/
- void SetProperty( Property::Index index, const Property::Value& propertyValue );
+ void SetProperty(Property::Index index, Property::Value propertyValue);
/**
* @brief Registers a new animatable property.
* - Property::ROTATION
* @note If a property with the desired name already exists, then the value given is just set.
*/
- Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue );
+ Property::Index RegisterProperty(std::string name, Property::Value propertyValue);
/**
* @brief Register a new animatable property with an integer key.
* - Property::ROTATION
* @note If a property with the desired name already exists, then the value given is just set.
*/
- Property::Index RegisterProperty( Property::Index key,
- const std::string& name,
- const Property::Value& propertyValue );
+ Property::Index RegisterProperty(Property::Index key,
+ std::string name,
+ Property::Value propertyValue);
/**
* @brief Registers a new property.
* - Property::ROTATION
* @note If a property with the desired name already exists, then the value given is just set.
*/
- Property::Index RegisterProperty( const std::string& name, const Property::Value& propertyValue, Property::AccessMode accessMode );
+ Property::Index RegisterProperty(std::string name, Property::Value propertyValue, Property::AccessMode accessMode);
/**
* @brief Retrieves a property value.
* @param[in] index The index of the property
* @return The property value
*/
- Property::Value GetProperty( Property::Index index ) const;
+ Property::Value GetProperty(Property::Index index) const;
/**
* @brief Convenience function for obtaining a property of a known type.
* @return The property value
* @pre The property types match i.e. PropertyTypes::Get<T>() is equal to GetPropertyType(index).
*/
- template <typename T>
- T GetProperty( Property::Index index ) const
+ template<typename T>
+ T GetProperty(Property::Index index) const
{
Property::Value value = GetProperty(index);
- return T( value.Get<T>() );
+ return T(value.Get<T>());
}
/**
* @param[in] index The index of the property
* @return The property value
*/
- Property::Value GetCurrentProperty( Property::Index index ) const;
+ Property::Value GetCurrentProperty(Property::Index index) const;
/**
* @brief Convenience function for obtaining the current value of a property of a known type.
* @return The property value
* @pre The property types match i.e. PropertyTypes::Get<T>() is equal to GetPropertyType(index).
*/
- template <typename T>
- T GetCurrentProperty( Property::Index index ) const
+ template<typename T>
+ T GetCurrentProperty(Property::Index index) const
{
- Property::Value value = GetCurrentProperty( index );
+ Property::Value value = GetCurrentProperty(index);
- return T( value.Get<T>() );
+ return T(value.Get<T>());
}
/**
* @SINCE_1_9.27
* @param[in] properties The properties to set
*/
- void SetProperties( const Property::Map& properties );
+ void SetProperties(const Property::Map& properties);
/**
* @brief Retrieves all the properties and the values for this object
*
* @note The properties map will be cleared by this method first.
*/
- void GetProperties( Property::Map& properties );
+ void GetProperties(Property::Map& properties);
/**
* @brief Retrieves all the property indices for this object (including custom properties).
* @param[out] indices A container of property indices for this object
* @note The added container is cleared.
*/
- void GetPropertyIndices( Property::IndexContainer& indices ) const;
+ void GetPropertyIndices(Property::IndexContainer& indices) const;
/**
* @brief Determine if the custom property index exists on this object without throwing a Dali::Exception.
* @note This does not check default properties.
* @param[in] index The index of the property to test for
*/
- bool DoesCustomPropertyExist( Property::Index index );
+ bool DoesCustomPropertyExist(Property::Index index);
/**
* @brief Adds a property notification to this object.
* @param[in] condition The notification will be triggered when this condition is satisfied
* @return A handle to the newly created PropertyNotification
*/
- PropertyNotification AddPropertyNotification( Property::Index index,
- const PropertyCondition& condition );
+ PropertyNotification AddPropertyNotification(Property::Index index,
+ const PropertyCondition& condition);
/**
* @brief Adds a property notification to this object.
* @param[in] condition The notification will be triggered when this condition is satisfied
* @return A handle to the newly created PropertyNotification
*/
- PropertyNotification AddPropertyNotification( Property::Index index,
- int componentIndex,
- const PropertyCondition& condition );
+ PropertyNotification AddPropertyNotification(Property::Index index,
+ int componentIndex,
+ const PropertyCondition& condition);
/**
* @brief Removes a property notification from this object.
* @SINCE_1_0.0
* @param[in] propertyNotification The propertyNotification to be removed
*/
- void RemovePropertyNotification( Dali::PropertyNotification propertyNotification );
+ void RemovePropertyNotification(Dali::PropertyNotification propertyNotification);
/**
* @brief Removes all property notifications from this object.
* @param[in] tag The tag of the constraints which will be removed
* @pre The Object has been initialized.
*/
- void RemoveConstraints( uint32_t tag );
+ void RemoveConstraints(uint32_t tag);
/**
* @brief Index operator, using integer lookup.
* @param[in] index The index of the property to access.
* @return indirect value. Should have shorter scope than the handle
*/
- IndirectValue operator[]( Property::Index index );
+ IndirectValue operator[](Property::Index index);
/**
* @brief Index operator, using name lookup.
* @param[in] name The name of the property to access.
* @return indirect value. Should have shorter scope than the handle
*/
- IndirectValue operator[]( const std::string& name );
+ IndirectValue operator[](const std::string& name);
public: // Signals
/**
*/
namespace WeightObject
{
-
DALI_CORE_API extern const Property::Index WEIGHT; ///< name "weight", type FLOAT
/**
* limitations under the License.
*/
-
-#include <dali/public-api/object/indirect-value.h>
-#include <dali/public-api/object/handle.h>
#include <dali/internal/event/common/object-impl.h>
+#include <dali/public-api/object/handle.h>
+#include <dali/public-api/object/indirect-value.h>
namespace Dali
{
-
-IndirectValue::IndirectValue( Handle& handle, Property::Index index )
+IndirectValue::IndirectValue(Handle& handle, Property::Index index)
: mHandle(handle.GetObjectPtr()),
mIndex(index),
mExtension(nullptr)
{
}
-void IndirectValue::operator= (Property::Value value)
+void IndirectValue::operator=(Property::Value value)
{
Handle(static_cast<Dali::Internal::Object*>(mHandle.Get())).SetProperty(mIndex, value);
}
return Handle(static_cast<Dali::Internal::Object*>(mHandle.Get())).GetProperty(mIndex);
}
-IndirectValue& IndirectValue::operator=( IndirectValue&& ) = default;
-
-IndirectValue::IndirectValue( IndirectValue&& ) = default;
+IndirectValue& IndirectValue::operator=(IndirectValue&&) = default;
+IndirectValue::IndirectValue(IndirectValue&&) = default;
} // namespace Dali
*/
#include <dali/public-api/common/intrusive-ptr.h>
-#include <dali/public-api/object/property.h>
#include <dali/public-api/object/property-value.h>
+#include <dali/public-api/object/property.h>
#include <dali/public-api/object/ref-object.h>
namespace Dali
class Handle;
-
/**
* @brief Dali::IndirectValue is an intermediate object that enables a simpler
* syntax for addressing properties.
* @tparam Type The type of the associated property
* @return The associated property cast to the desired type
*/
- template <typename Type>
+ template<typename Type>
inline operator Type()
{
Property::Value value = GetProperty();
* Making this private to prevent construction of auto type or IndirectValue type.
* @param[in] rhs The object to move
*/
- DALI_INTERNAL IndirectValue( IndirectValue&& rhs );
+ DALI_INTERNAL IndirectValue(IndirectValue&& rhs);
/**
* @brief Move assignment operator.
* Making this private to prevent assignment to auto type or IndirectValue type.
* @param[in] rhs The object to move
*/
- DALI_INTERNAL IndirectValue& operator=( IndirectValue&& rhs );
+ DALI_INTERNAL IndirectValue& operator=(IndirectValue&& rhs);
/**
* @brief Accessor for handle property.
* @param[in] handle A reference to the associated handle
* @param[in] index The index to the associated property
*/
- DALI_INTERNAL IndirectValue( Handle& handle, Property::Index index );
+ DALI_INTERNAL IndirectValue(Handle& handle, Property::Index index);
+
private:
IntrusivePtr<Dali::RefObject> mHandle; ///< A handle to the property owner
- Property::Index mIndex; ///< Index of the property in the property owner.
+ Property::Index mIndex; ///< Index of the property in the property owner.
- struct Extension; ///< Reserved for future use
+ struct Extension; ///< Reserved for future use
Extension* mExtension; ///< Reserved for future use
/// @endcond
namespace Dali
{
-
ObjectRegistry::ObjectRegistry()
{
}
ObjectRegistry& ObjectRegistry::operator=(const ObjectRegistry& rhs) = default;
-ObjectRegistry::ObjectRegistry( ObjectRegistry&& rhs ) = default;
+ObjectRegistry::ObjectRegistry(ObjectRegistry&& rhs) = default;
-ObjectRegistry& ObjectRegistry::operator=( ObjectRegistry&& rhs ) = default;
+ObjectRegistry& ObjectRegistry::operator=(ObjectRegistry&& rhs) = default;
ObjectRegistry::ObjectCreatedSignalType& ObjectRegistry::ObjectCreatedSignal()
{
class DALI_CORE_API ObjectRegistry : public BaseHandle
{
public:
-
// Typedefs
/**
* @brief Object created signal.
* @SINCE_1_0.0
*/
- typedef Signal< void ( BaseHandle ) > ObjectCreatedSignalType;
+ using ObjectCreatedSignalType = Signal<void(BaseHandle)>;
/**
* @brief Object destroyed signal.
* @SINCE_1_0.0
*/
- typedef Signal< void ( const Dali::RefObject* ) > ObjectDestroyedSignalType;
+ using ObjectDestroyedSignalType = Signal<void(const Dali::RefObject*)>;
/**
* @brief Allows the creation of an empty objectRegistry handle.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- ObjectRegistry( ObjectRegistry&& rhs );
+ ObjectRegistry(ObjectRegistry&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- ObjectRegistry& operator=( ObjectRegistry&& rhs );
+ ObjectRegistry& operator=(ObjectRegistry&& rhs);
public: // Signals
-
/**
* @brief This signal is emitted when an object is created.
*
ObjectDestroyedSignalType& ObjectDestroyedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali Get() method.
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace
{
}; // unnamed namespace
};
Property::Array::Array()
-: mImpl( new Impl )
+: mImpl(new Impl)
{
}
-Property::Array::Array( const std::initializer_list< Property::Value >& values )
+Property::Array::Array(const std::initializer_list<Property::Value>& values)
: Array()
{
- for( auto&& value : values )
+ for(auto&& value : values)
{
- PushBack( value );
+ PushBack(value);
}
}
-Property::Array::Array( const Property::Array& other )
-: mImpl( new Impl )
+Property::Array::Array(const Property::Array& other)
+: mImpl(new Impl)
{
mImpl->mArray = other.mImpl->mArray;
}
-Property::Array::Array( Property::Array&& other )
-: mImpl( other.mImpl )
+Property::Array::Array(Property::Array&& other)
+: mImpl(other.mImpl)
{
other.mImpl = nullptr;
}
Property::Array::SizeType Property::Array::Count() const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
return mImpl->mArray.size();
}
-void Property::Array::PushBack( const Value& value )
+void Property::Array::PushBack(const Value& value)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
- mImpl->mArray.push_back( value );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
+ mImpl->mArray.push_back(value);
}
void Property::Array::Clear()
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
mImpl->mArray.clear();
}
-void Property::Array::Reserve( SizeType size )
+void Property::Array::Reserve(SizeType size)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
mImpl->mArray.reserve(size);
}
-void Property::Array::Resize( SizeType size )
+void Property::Array::Resize(SizeType size)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
mImpl->mArray.resize(size);
}
Property::Array::SizeType Property::Array::Capacity()
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
return mImpl->mArray.capacity();
}
-const Property::Value& Property::Array::operator[]( SizeType index ) const
+const Property::Value& Property::Array::operator[](SizeType index) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
// Note says no bounds checking is performed so we don't need to verify mImpl as Count() will return 0 anyway
- return mImpl->mArray[ index ];
+ return mImpl->mArray[index];
}
-Property::Value& Property::Array::operator[]( SizeType index )
+Property::Value& Property::Array::operator[](SizeType index)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
// Note says no bounds checking is performed so we don't need to verify mImpl as Count() will return 0 anyway
- return mImpl->mArray[ index ];
+ return mImpl->mArray[index];
}
-Property::Array& Property::Array::operator=( const Property::Array& other )
+Property::Array& Property::Array::operator=(const Property::Array& other)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- if( this != &other )
+ if(this != &other)
{
mImpl->mArray = other.mImpl->mArray;
}
return *this;
}
-Property::Array& Property::Array::operator=( Property::Array&& other )
+Property::Array& Property::Array::operator=(Property::Array&& other)
{
- if( this != &other )
+ if(this != &other)
{
delete mImpl;
- mImpl = other.mImpl;
+ mImpl = other.mImpl;
other.mImpl = nullptr;
}
return *this;
}
-std::ostream& operator<<( std::ostream& stream, const Property::Array& array )
+std::ostream& operator<<(std::ostream& stream, const Property::Array& array)
{
stream << "Array(" << array.Count() << ") = [";
- for( Property::Array::SizeType i=0; i<array.Count(); ++i )
+ for(Property::Array::SizeType i = 0; i < array.Count(); ++i)
{
- if( i>0 )
+ if(i > 0)
{
stream << ", ";
}
return stream;
}
-
} // namespace Dali
#define DALI_PROPERTY_ARRAY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 DALI_CORE_API Property::Array
{
public:
-
- typedef std::size_t SizeType;
+ using SizeType = std::size_t;
/**
* @brief Default constructor.
* @SINCE_1_4.17
* @param[in] values An initializer_list of values
*/
- Array( const std::initializer_list< Value >& values );
+ Array(const std::initializer_list<Value>& values);
/**
* @brief Copy constructor.
* @SINCE_1_0.0
* @param[in] other The Array to copy from
*/
- Array( const Array& other );
+ Array(const Array& other);
/**
* @brief Move constructor.
* @param[in] other The Array to move from
* @note After the @a other array is used, it becomes invalid and is no longer usable.
*/
- Array( Array&& other );
+ Array(Array&& other);
/**
* @brief Non-virtual destructor.
* @SINCE_1_0.0
* @param[in] size The size to reserve
*/
- void Reserve( SizeType size );
+ void Reserve(SizeType size);
/**
* @brief Resizes to size.
* @SINCE_1_0.0
* @param[in] size The size to resize
*/
- void Resize( SizeType size );
+ void Resize(SizeType size);
/**
* @brief Retrieves the capacity of the array.
* @SINCE_1_0.0
* @param[in] value The value to add to the end of the array
*/
- void PushBack( const Value& value );
+ void PushBack(const Value& value);
/**
* @brief Add an element to the array.
* @param[in] value The value to add to the end of the array
* @return A reference to this object
*/
- inline Property::Array& Add( const Value& value )
+ inline Property::Array& Add(const Value& value)
{
- PushBack( value );
+ PushBack(value);
return *this;
}
* @param[in] index The element index to access. No bounds checking is performed
* @return The a reference to the element
*/
- const Value& GetElementAt( SizeType index ) const
+ const Value& GetElementAt(SizeType index) const
{
- return operator[]( index );
+ return operator[](index);
}
/**
* @param[in] index The element index to access. No bounds checking is performed
* @return The a reference to the element
*/
- Value& GetElementAt( SizeType index )
+ Value& GetElementAt(SizeType index)
{
- return operator[]( index );
+ return operator[](index);
}
/**
* @return The a reference to the element
*
*/
- const Value& operator[]( SizeType index ) const;
+ const Value& operator[](SizeType index) const;
/**
* @brief Operator to access an element.
* @return The a reference to the element
*
*/
- Value& operator[]( SizeType index );
+ Value& operator[](SizeType index);
/**
* @brief Assignment operator.
*
* @return The copied array.
*/
- Array& operator=( const Array& other );
+ Array& operator=(const Array& other);
/**
* @brief Move assignment operator.
*
* @note After the @a other array is used, it becomes invalid and is no longer usable.
*/
- Array& operator=( Array&& other );
+ Array& operator=(Array&& other);
/**
* @brief Output to stream.
* @SINCE_1_1.28
*/
- friend DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Array& array );
+ friend DALI_CORE_API std::ostream& operator<<(std::ostream& stream, const Property::Array& array);
private:
- struct DALI_INTERNAL Impl; ///< Private data
- Impl* mImpl; ///< Pointer to private data
+ struct DALI_INTERNAL Impl; ///< Private data
+ Impl* mImpl; ///< Pointer to private data
};
/**
* @param[in] array The array to insert
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Array& array );
+DALI_CORE_API std::ostream& operator<<(std::ostream& stream, const Property::Array& array);
/**
* @}
#include <dali/public-api/object/property-conditions.h>
// INTERNAL INCLUDES
-#include <dali/public-api/object/property-value.h>
#include <dali/internal/event/common/property-conditions-impl.h>
+#include <dali/public-api/object/property-value.h>
namespace Dali
{
-
PropertyCondition::PropertyCondition()
: BaseHandle(new Internal::PropertyCondition())
{
-
}
PropertyCondition::~PropertyCondition()
{
-
}
-PropertyCondition::PropertyCondition( const PropertyCondition& handle ) = default;
+PropertyCondition::PropertyCondition(const PropertyCondition& handle) = default;
-PropertyCondition& PropertyCondition::operator=( const PropertyCondition& rhs ) = default;
+PropertyCondition& PropertyCondition::operator=(const PropertyCondition& rhs) = default;
-PropertyCondition::PropertyCondition( PropertyCondition&& rhs ) = default;
+PropertyCondition::PropertyCondition(PropertyCondition&& rhs) = default;
-PropertyCondition& PropertyCondition::operator=( PropertyCondition&& rhs ) = default;
+PropertyCondition& PropertyCondition::operator=(PropertyCondition&& rhs) = default;
std::size_t PropertyCondition::GetArgumentCount() const
{
return GetImplementation(*this).arguments.Count();
}
-float PropertyCondition::GetArgument( std::size_t index ) const
+float PropertyCondition::GetArgument(std::size_t index) const
{
- return GetImplementation(*this).arguments[ index ];
+ return GetImplementation(*this).arguments[index];
}
-PropertyCondition LessThanCondition( float arg )
+PropertyCondition LessThanCondition(float arg)
{
- PropertyCondition condition;
- Internal::PropertyCondition& impl = GetImplementation( condition );
- impl.type = Internal::PropertyCondition::LessThan;
- impl.arguments.PushBack( arg );
+ PropertyCondition condition;
+ Internal::PropertyCondition& impl = GetImplementation(condition);
+ impl.type = Internal::PropertyCondition::LessThan;
+ impl.arguments.PushBack(arg);
return condition;
}
-PropertyCondition GreaterThanCondition( float arg )
+PropertyCondition GreaterThanCondition(float arg)
{
- PropertyCondition condition;
- Internal::PropertyCondition& impl = GetImplementation( condition );
- impl.type = Internal::PropertyCondition::GreaterThan;
- impl.arguments.PushBack( arg );
+ PropertyCondition condition;
+ Internal::PropertyCondition& impl = GetImplementation(condition);
+ impl.type = Internal::PropertyCondition::GreaterThan;
+ impl.arguments.PushBack(arg);
return condition;
}
-PropertyCondition InsideCondition( float arg0, float arg1 )
+PropertyCondition InsideCondition(float arg0, float arg1)
{
- PropertyCondition condition;
- Internal::PropertyCondition& impl = GetImplementation( condition );
- impl.type = Internal::PropertyCondition::Inside;
- impl.arguments.PushBack( arg0 );
- impl.arguments.PushBack( arg1 );
+ PropertyCondition condition;
+ Internal::PropertyCondition& impl = GetImplementation(condition);
+ impl.type = Internal::PropertyCondition::Inside;
+ impl.arguments.PushBack(arg0);
+ impl.arguments.PushBack(arg1);
return condition;
}
-PropertyCondition OutsideCondition( float arg0, float arg1 )
+PropertyCondition OutsideCondition(float arg0, float arg1)
{
- PropertyCondition condition;
- Internal::PropertyCondition& impl = GetImplementation( condition );
- impl.type = Internal::PropertyCondition::Outside;
- impl.arguments.PushBack( arg0 );
- impl.arguments.PushBack( arg1 );
+ PropertyCondition condition;
+ Internal::PropertyCondition& impl = GetImplementation(condition);
+ impl.type = Internal::PropertyCondition::Outside;
+ impl.arguments.PushBack(arg0);
+ impl.arguments.PushBack(arg1);
return condition;
}
-PropertyCondition StepCondition( float stepAmount, float referenceValue )
+PropertyCondition StepCondition(float stepAmount, float referenceValue)
{
- PropertyCondition condition;
- Internal::PropertyCondition& impl = GetImplementation( condition );
- impl.type = Internal::PropertyCondition::Step;
- impl.arguments.PushBack( referenceValue );
- impl.arguments.PushBack( 1.0f / stepAmount );
- impl.arguments.PushBack( 0.0f ); // current step
+ PropertyCondition condition;
+ Internal::PropertyCondition& impl = GetImplementation(condition);
+ impl.type = Internal::PropertyCondition::Step;
+ impl.arguments.PushBack(referenceValue);
+ impl.arguments.PushBack(1.0f / stepAmount);
+ impl.arguments.PushBack(0.0f); // current step
return condition;
}
-PropertyCondition VariableStepCondition( const Dali::Vector<float>& stepAmount )
+PropertyCondition VariableStepCondition(const Dali::Vector<float>& stepAmount)
{
- PropertyCondition condition;
- Internal::PropertyCondition& impl = GetImplementation( condition );
- impl.type = Internal::PropertyCondition::VariableStep;
- impl.arguments.PushBack( 0.0f ); // current step
+ PropertyCondition condition;
+ Internal::PropertyCondition& impl = GetImplementation(condition);
+ impl.type = Internal::PropertyCondition::VariableStep;
+ impl.arguments.PushBack(0.0f); // current step
Dali::Vector<float>::SizeType count = stepAmount.Count();
- impl.arguments.PushBack( float( count ) ); // store number of steps
- for( Dali::Vector<float>::SizeType index = 0; index < count; ++index )
+ impl.arguments.PushBack(float(count)); // store number of steps
+ for(Dali::Vector<float>::SizeType index = 0; index < count; ++index)
{
- impl.arguments.PushBack( stepAmount[index] );
+ impl.arguments.PushBack(stepAmount[index]);
}
return condition;
class DALI_CORE_API PropertyCondition : public BaseHandle
{
public:
-
/**
* @brief Constructor for condition clause.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] handle A reference to the copied handle
*/
- PropertyCondition( const PropertyCondition& handle );
+ PropertyCondition(const PropertyCondition& handle);
/**
* @brief This assignment operator is required for (smart) pointer semantics.
* @param[in] rhs A reference to the copied handle
* @return A reference to this
*/
- PropertyCondition& operator=( const PropertyCondition& rhs );
+ PropertyCondition& operator=(const PropertyCondition& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- PropertyCondition( PropertyCondition&& rhs );
+ PropertyCondition(PropertyCondition&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- PropertyCondition& operator=( PropertyCondition&& rhs );
+ PropertyCondition& operator=(PropertyCondition&& rhs);
public:
-
/**
* @brief Retrieves the arguments that this condition uses.
*
* @return The arguments used for this condition
* @note The container will only be valid as long PropertyCondition is valid.
*/
- float GetArgument( std::size_t index ) const;
-
+ float GetArgument(std::size_t index) const;
};
/**
* @param[in] arg The argument for the condition
* @return A property condition function object
*/
-DALI_CORE_API PropertyCondition LessThanCondition( float arg );
+DALI_CORE_API PropertyCondition LessThanCondition(float arg);
/**
* @brief GreaterThanCondition compares whether property is greater than arg.
* @param[in] arg The argument for the condition
* @return A property condition function object
*/
-DALI_CORE_API PropertyCondition GreaterThanCondition( float arg );
+DALI_CORE_API PropertyCondition GreaterThanCondition(float arg);
/**
* @brief InsideCondition compares whether property is greater than arg0 and less than arg1.
* @param[in] arg1 The second argument for the condition
* @return A property condition function object
*/
-DALI_CORE_API PropertyCondition InsideCondition( float arg0, float arg1 );
+DALI_CORE_API PropertyCondition InsideCondition(float arg0, float arg1);
/**
* @brief OutsideCondition compares whether property is less than arg0 or greater than arg1.
* @param[in] arg1 The second argument for the condition
* @return A property condition function object
*/
-DALI_CORE_API PropertyCondition OutsideCondition( float arg0, float arg1 );
+DALI_CORE_API PropertyCondition OutsideCondition(float arg0, float arg1);
/**
* @brief Detects when a property changes by stepAmount from initialValue, in both positive and negative directions. This will continue checking for multiples of stepAmount.
* @param[in] initialValue The initial value to step from
* @return A property condition function object
*/
-DALI_CORE_API PropertyCondition StepCondition( float stepAmount, float initialValue = 0.0f );
+DALI_CORE_API PropertyCondition StepCondition(float stepAmount, float initialValue = 0.0f);
/**
* @brief Receives notifications as a property goes above/below the inputted values. Values must be ordered and can be either ascending or descending.
* @param[in] steps List of values to receive notifications for as a property crosses them
* @return A property condition function object
*/
-DALI_CORE_API PropertyCondition VariableStepCondition( const Dali::Vector<float>& steps );
+DALI_CORE_API PropertyCondition VariableStepCondition(const Dali::Vector<float>& steps);
/**
* @}
#define DALI_PROPERTY_INDEX_RANGES_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* used to compare property indices.
* @SINCE_1_0.0
*/
+// clang-format off
enum PropertyRanges
{
- DEFAULT_OBJECT_PROPERTY_START_INDEX = 0, ///< For all objects deriving from Handle (including Actors). @SINCE_1_0.0
-
- DEFAULT_ACTOR_PROPERTY_START_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< Start index for Actor. @SINCE_1_0.0
- DEFAULT_ACTOR_PROPERTY_MAX_COUNT = 10000, ///< Actor range: 0 to 9999 @SINCE_1_0.0
+ DEFAULT_OBJECT_PROPERTY_START_INDEX = 0, ///< For all objects deriving from Handle (including Actors). @SINCE_1_0.0
+ DEFAULT_ACTOR_PROPERTY_START_INDEX = DEFAULT_OBJECT_PROPERTY_START_INDEX, ///< Start index for Actor. @SINCE_1_0.0
+ DEFAULT_ACTOR_PROPERTY_MAX_COUNT = 10000, ///< Actor range: 0 to 9999 @SINCE_1_0.0
DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX = DEFAULT_ACTOR_PROPERTY_START_INDEX + DEFAULT_ACTOR_PROPERTY_MAX_COUNT, ///< Property start index for classes deriving directly from Actor. @SINCE_1_0.0
+ DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION = 10000, ///< Second-level and onwards derived objects should increment their start index by this. @SINCE_1_0.0
- DEFAULT_PROPERTY_MAX_COUNT_PER_DERIVATION = 10000, ///< Second-level and onwards derived objects should increment their start index by this. @SINCE_1_0.0
-
- DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< Used by PanGestureDetector. @SINCE_1_0.0
+ DEFAULT_GESTURE_DETECTOR_PROPERTY_START_INDEX = DEFAULT_DERIVED_ACTOR_PROPERTY_START_INDEX, ///< Used by PanGestureDetector. @SINCE_1_0.0
- DEFAULT_RENDERER_PROPERTY_START_INDEX = 9000000, ///< Start index for Renderer. @SINCE_1_1.44
- DEFAULT_RENDERER_PROPERTY_MAX_INDEX = DEFAULT_RENDERER_PROPERTY_START_INDEX + 100000, ///< Renderer range: 9000000 to 9100000 @SINCE_1_1.44
+ DEFAULT_RENDERER_PROPERTY_START_INDEX = 9000000, ///< Start index for Renderer. @SINCE_1_1.44
+ DEFAULT_RENDERER_PROPERTY_MAX_INDEX = DEFAULT_RENDERER_PROPERTY_START_INDEX + 100000, ///< Renderer range: 9000000 to 9100000 @SINCE_1_1.44
- PROPERTY_REGISTRATION_START_INDEX = 10000000, ///< The index when registering a property should start from this number. @SINCE_1_0.0
- DEFAULT_PROPERTY_MAX_COUNT = PROPERTY_REGISTRATION_START_INDEX, ///< Default Property Range: 0 to 9999999 @SINCE_1_0.0
+ PROPERTY_REGISTRATION_START_INDEX = 10000000, ///< The index when registering a property should start from this number. @SINCE_1_0.0
+ DEFAULT_PROPERTY_MAX_COUNT = PROPERTY_REGISTRATION_START_INDEX, ///< Default Property Range: 0 to 9999999 @SINCE_1_0.0
- PROPERTY_REGISTRATION_MAX_INDEX = 19999999, ///< The maximum index supported when registering a property @SINCE_1_0.0
+ PROPERTY_REGISTRATION_MAX_INDEX = 19999999, ///< The maximum index supported when registering a property @SINCE_1_0.0
- ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX = 20000000, ///< The index when registering an animatable property should start from this number. (SceneGraph properties per type) @SINCE_1_0.0
- ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX = 29999999, ///< The maximum index supported when registering an animatable property @SINCE_1_0.0
+ ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX = 20000000, ///< The index when registering an animatable property should start from this number. (SceneGraph properties per type) @SINCE_1_0.0
+ ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX = 29999999, ///< The maximum index supported when registering an animatable property @SINCE_1_0.0
- CHILD_PROPERTY_REGISTRATION_START_INDEX = 45000000, ///< The index when registering a child property should start from this number. (Event side properties per instance) @SINCE_1_1.35
- CHILD_PROPERTY_REGISTRATION_MAX_INDEX = 49999999, ///< The maximum index supported when registering a child property @SINCE_1_1.35
+ CHILD_PROPERTY_REGISTRATION_START_INDEX = 45000000, ///< The index when registering a child property should start from this number. (Event side properties per instance) @SINCE_1_1.35
+ CHILD_PROPERTY_REGISTRATION_MAX_INDEX = 49999999, ///< The maximum index supported when registering a child property @SINCE_1_1.35
- PROPERTY_CUSTOM_START_INDEX = 50000000, ///< The index at which custom properties start (SceneGraph and Event side properties per instance) @SINCE_1_0.0
- PROPERTY_CUSTOM_MAX_INDEX = 59999999, ///< The maximum index supported for custom properties @SINCE_1_1.45
+ PROPERTY_CUSTOM_START_INDEX = 50000000, ///< The index at which custom properties start (SceneGraph and Event side properties per instance) @SINCE_1_0.0
+ PROPERTY_CUSTOM_MAX_INDEX = 59999999, ///< The maximum index supported for custom properties @SINCE_1_1.45
- CORE_PROPERTY_MAX_INDEX = PROPERTY_CUSTOM_MAX_INDEX, ///< The maximum index that Core properties can go up to @SINCE_1_1.45
+ CORE_PROPERTY_MAX_INDEX = PROPERTY_CUSTOM_MAX_INDEX, ///< The maximum index that Core properties can go up to @SINCE_1_1.45
};
+// clang-format on
/**
* @}
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
PropertyInput::~PropertyInput()
{
}
#define DALI_PROPERTY_INPUT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 DALI_CORE_API PropertyInput
{
public:
-
class Extension; ///< Forward declare future extension interface
/**
*/
virtual Extension* GetExtension()
{
- return NULL;
+ return nullptr;
}
};
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/object/property-key.h>
-
namespace Dali
{
-
-Property::Key::Key( const std::string& key )
-: type( Key::STRING ),
- indexKey( Property::INVALID_INDEX ),
- stringKey( key )
+Property::Key::Key(const std::string& key)
+: type(Key::STRING),
+ indexKey(Property::INVALID_INDEX),
+ stringKey(key)
{
}
-Property::Key::Key( Property::Index key )
-: type( Key::INDEX ),
- indexKey( key )
+Property::Key::Key(Property::Index key)
+: type(Key::INDEX),
+ indexKey(key)
{
}
-Property::Key::Key( const char * key )
-: type( Key::STRING ),
- indexKey( Property::INVALID_INDEX ),
- stringKey( key )
+Property::Key::Key(const char* key)
+: type(Key::STRING),
+ indexKey(Property::INVALID_INDEX),
+ stringKey(key)
{
}
-bool Property::Key::operator== (const std::string& rhs)
+bool Property::Key::operator==(const std::string& rhs)
{
- bool result=false;
+ bool result = false;
if(type == Key::STRING)
{
result = (stringKey == rhs);
return result;
}
-bool Property::Key::operator== ( const char* rhs )
+bool Property::Key::operator==(const char* rhs)
{
- return operator==( std::string( rhs ) );
+ return operator==(std::string(rhs));
}
-bool Property::Key::operator== (Property::Index rhs)
+bool Property::Key::operator==(Property::Index rhs)
{
- bool result=false;
+ bool result = false;
if(type == Key::INDEX)
{
result = (indexKey == rhs);
return result;
}
-bool Property::Key::operator== (const Key& rhs)
+bool Property::Key::operator==(const Key& rhs)
{
- bool result=false;
- if(type == Key::STRING && rhs.type == Key::STRING )
+ bool result = false;
+ if(type == Key::STRING && rhs.type == Key::STRING)
{
result = (stringKey == rhs.stringKey);
}
- else if( type == Key::INDEX && rhs.type == Key::INDEX )
+ else if(type == Key::INDEX && rhs.type == Key::INDEX)
{
result = (indexKey == rhs.indexKey);
}
return result;
}
-bool Property::Key::operator!= (const std::string& rhs)
+bool Property::Key::operator!=(const std::string& rhs)
{
return !operator==(rhs);
}
-bool Property::Key::operator!= ( const char* rhs )
+bool Property::Key::operator!=(const char* rhs)
{
return !operator==(rhs);
}
-bool Property::Key::operator!= (Property::Index rhs)
+bool Property::Key::operator!=(Property::Index rhs)
{
return !operator==(rhs);
}
-bool Property::Key::operator!= (const Key& rhs)
+bool Property::Key::operator!=(const Key& rhs)
{
return !operator==(rhs);
}
-std::ostream& operator<<( std::ostream& stream, const Property::Key& key )
+std::ostream& operator<<(std::ostream& stream, const Property::Key& key)
{
- if( key.type == Property::Key::INDEX )
+ if(key.type == Property::Key::INDEX)
{
stream << key.indexKey;
}
#define DALI_PROPERTY_KEY_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
#include <sstream>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
{
INDEX, ///< The key is a Property::Index
STRING ///< The key is a string
- } type; ///< The type of the key
+ } type; ///< The type of the key
- Property::Index indexKey; ///< The index key.
- std::string stringKey; ///< The string key.
+ Property::Index indexKey; ///< The index key.
+ std::string stringKey; ///< The string key.
/**
* @brief Constructor
*
* @param[in] key The string key
*/
- Key( const std::string& key );
+ Key(const std::string& key);
/**
* @brief Constructor
*
* @param[in] key The string key as a const char *
*/
- Key( const char * key );
+ Key(const char* key);
/**
* @brief Constructor
*
* @param[in] key The index key
*/
- Key( Property::Index key );
+ Key(Property::Index key);
/**
* @brief The equality operator
* @param[in] rhs A string key to compare against.
* @return true if the key compares, or false if it isn't equal or of the wrong type
*/
- bool operator== (const std::string& rhs);
+ bool operator==(const std::string& rhs);
/**
* @brief Constructor
* @param[in] key The string key as a const char *
* @return true if the key compares, or false if it isn't equal or of the wrong type
*/
- bool operator== ( const char * key );
+ bool operator==(const char* key);
/**
* @brief The equality operator
* @param[in] rhs An index key to compare against.
* @return true if the key compares, or false if it isn't equal or of the wrong type
*/
- bool operator== (Property::Index rhs);
+ bool operator==(Property::Index rhs);
/**
* @brief The equality operator
* @param[in] rhs A key to compare against.
* @return true if the keys are of the same type and have the same value
*/
- bool operator== (const Key& rhs);
+ bool operator==(const Key& rhs);
/**
* @brief The inequality operator
* @param[in] rhs A string key to compare against.
* @return true if the key is not equal or not a string key
*/
- bool operator!= (const std::string& rhs);
+ bool operator!=(const std::string& rhs);
/**
* @brief The inequality operator
* @param[in] rhs A const char* key to compare against.
* @return true if the key is not equal or not a string key
*/
- bool operator!= ( const char* rhs );
+ bool operator!=(const char* rhs);
/**
* @brief The inequality operator
* @param[in] rhs An index key to compare against.
* @return true if the key is not equal, or not an index key
*/
- bool operator!= (Property::Index rhs);
+ bool operator!=(Property::Index rhs);
/**
* @brief The inequality operator
* @param[in] rhs A key to compare against.
* @return true if the keys are not of the same type or are not equal
*/
- bool operator!= (const Key& rhs);
+ bool operator!=(const Key& rhs);
};
/**
* @param [in] key the key to convert
* @return The output stream operator.
*/
-DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Key& key );
-
+DALI_CORE_API std::ostream& operator<<(std::ostream& stream, const Property::Key& key);
/**
* @}
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace
{
-typedef std::vector< StringValuePair > StringValueContainer;
+typedef std::vector<StringValuePair> StringValueContainer;
-typedef std::pair< Property::Index, Property::Value > IndexValuePair;
-typedef std::vector< IndexValuePair > IndexValueContainer;
+using IndexValuePair = std::pair<Property::Index, Property::Value>;
+using IndexValueContainer = std::vector<IndexValuePair>;
}; // unnamed namespace
-
struct Property::Map::Impl
{
StringValueContainer mStringValueContainer;
- IndexValueContainer mIndexValueContainer;
+ IndexValueContainer mIndexValueContainer;
};
Property::Map::Map()
-: mImpl( new Impl )
+: mImpl(new Impl)
{
}
-Property::Map::Map( const std::initializer_list< KeyValuePair >& values ) : Map()
+Property::Map::Map(const std::initializer_list<KeyValuePair>& values)
+: Map()
{
- for( auto&& value : values )
+ for(auto&& value : values)
{
const auto& key = value.first;
- switch( key.type )
+ switch(key.type)
{
case Property::Key::INDEX:
{
- Property::Map::Insert( key.indexKey, value.second );
+ Property::Map::Insert(key.indexKey, value.second);
break;
}
case Property::Key::STRING:
{
- Property::Map::Insert( key.stringKey, value.second );
+ Property::Map::Insert(key.stringKey, value.second);
break;
}
}
}
}
-Property::Map::Map( const Property::Map& other )
-: mImpl( new Impl )
+Property::Map::Map(const Property::Map& other)
+: mImpl(new Impl)
{
mImpl->mStringValueContainer = other.mImpl->mStringValueContainer;
- mImpl->mIndexValueContainer = other.mImpl->mIndexValueContainer;
+ mImpl->mIndexValueContainer = other.mImpl->mIndexValueContainer;
}
-Property::Map::Map( Property::Map&& other )
-: mImpl( other.mImpl )
+Property::Map::Map(Property::Map&& other)
+: mImpl(other.mImpl)
{
other.mImpl = nullptr;
}
Property::Map::SizeType Property::Map::Count() const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
return mImpl->mStringValueContainer.size() + mImpl->mIndexValueContainer.size();
}
bool Property::Map::Empty() const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
return mImpl->mStringValueContainer.empty() && mImpl->mIndexValueContainer.empty();
}
-void Property::Map::Insert( const char* key, const Value& value )
+void Property::Map::Insert(const char* key, const Value& value)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
- mImpl->mStringValueContainer.push_back( std::make_pair( key, value ) );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
+ mImpl->mStringValueContainer.push_back(std::make_pair(key, value));
}
-void Property::Map::Insert( const std::string& key, const Value& value )
+void Property::Map::Insert(const std::string& key, const Value& value)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
- mImpl->mStringValueContainer.push_back( std::make_pair( key, value ) );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
+ mImpl->mStringValueContainer.push_back(std::make_pair(key, value));
}
-void Property::Map::Insert( Property::Index key, const Value& value )
+void Property::Map::Insert(Property::Index key, const Value& value)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
- mImpl->mIndexValueContainer.push_back( std::make_pair( key, value ) );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
+ mImpl->mIndexValueContainer.push_back(std::make_pair(key, value));
}
-Property::Value& Property::Map::GetValue( SizeType position ) const
+Property::Value& Property::Map::GetValue(SizeType position) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
SizeType numStringKeys = mImpl->mStringValueContainer.size();
SizeType numIndexKeys = mImpl->mIndexValueContainer.size();
- DALI_ASSERT_ALWAYS( position < ( numStringKeys + numIndexKeys ) && "position out-of-bounds" );
+ DALI_ASSERT_ALWAYS(position < (numStringKeys + numIndexKeys) && "position out-of-bounds");
- if( position < numStringKeys )
+ if(position < numStringKeys)
{
- return mImpl->mStringValueContainer[ position ].second;
+ return mImpl->mStringValueContainer[position].second;
}
else
{
- return mImpl->mIndexValueContainer[ position-numStringKeys ].second;
+ return mImpl->mIndexValueContainer[position - numStringKeys].second;
}
}
-const std::string& Property::Map::GetKey( SizeType position ) const
+const std::string& Property::Map::GetKey(SizeType position) const
{
- DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: GetKey() is deprecated and will be removed from next release.\n" );
+ DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: GetKey() is deprecated and will be removed from next release.\n");
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
SizeType numStringKeys = mImpl->mStringValueContainer.size();
- DALI_ASSERT_ALWAYS( position < numStringKeys && "position out-of-bounds" );
+ DALI_ASSERT_ALWAYS(position < numStringKeys && "position out-of-bounds");
- return mImpl->mStringValueContainer[ position ].first;
+ return mImpl->mStringValueContainer[position].first;
}
-Property::Key Property::Map::GetKeyAt( SizeType position ) const
+Property::Key Property::Map::GetKeyAt(SizeType position) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
SizeType numStringKeys = mImpl->mStringValueContainer.size();
SizeType numIndexKeys = mImpl->mIndexValueContainer.size();
- DALI_ASSERT_ALWAYS( position < ( numStringKeys + numIndexKeys ) && "position out-of-bounds" );
+ DALI_ASSERT_ALWAYS(position < (numStringKeys + numIndexKeys) && "position out-of-bounds");
- if( position < numStringKeys )
+ if(position < numStringKeys)
{
- Key key(mImpl->mStringValueContainer[ position ].first);
+ Key key(mImpl->mStringValueContainer[position].first);
return key;
}
else
{
- Key key( mImpl->mIndexValueContainer[ position-numStringKeys ].first );
+ Key key(mImpl->mIndexValueContainer[position - numStringKeys].first);
return key;
}
}
-StringValuePair& Property::Map::GetPair( SizeType position ) const
+StringValuePair& Property::Map::GetPair(SizeType position) const
{
- DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: GetPair() is deprecated and will be removed from next release.\n" );
+ DALI_LOG_WARNING_NOFN("DEPRECATION WARNING: GetPair() is deprecated and will be removed from next release.\n");
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
SizeType numStringKeys = mImpl->mStringValueContainer.size();
- DALI_ASSERT_ALWAYS( position < ( numStringKeys ) && "position out-of-bounds" );
+ DALI_ASSERT_ALWAYS(position < (numStringKeys) && "position out-of-bounds");
- return mImpl->mStringValueContainer[ position ];
+ return mImpl->mStringValueContainer[position];
}
-KeyValuePair Property::Map::GetKeyValue( SizeType position ) const
+KeyValuePair Property::Map::GetKeyValue(SizeType position) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
SizeType numStringKeys = mImpl->mStringValueContainer.size();
SizeType numIndexKeys = mImpl->mIndexValueContainer.size();
- DALI_ASSERT_ALWAYS( position < ( numStringKeys + numIndexKeys ) && "position out-of-bounds" );
+ DALI_ASSERT_ALWAYS(position < (numStringKeys + numIndexKeys) && "position out-of-bounds");
- if( position < numStringKeys )
+ if(position < numStringKeys)
{
- Key key(mImpl->mStringValueContainer[ position ].first);
- KeyValuePair keyValue(key, mImpl->mStringValueContainer[ position ].second );
+ Key key(mImpl->mStringValueContainer[position].first);
+ KeyValuePair keyValue(key, mImpl->mStringValueContainer[position].second);
return keyValue;
}
else
{
- Key key( mImpl->mIndexValueContainer[ position-numStringKeys ].first );
- KeyValuePair keyValue(key, mImpl->mIndexValueContainer[ position-numStringKeys ].second );
+ Key key(mImpl->mIndexValueContainer[position - numStringKeys].first);
+ KeyValuePair keyValue(key, mImpl->mIndexValueContainer[position - numStringKeys].second);
return keyValue;
}
}
-Property::Value* Property::Map::Find( const char* key ) const
+Property::Value* Property::Map::Find(const char* key) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mStringValueContainer )
+ for(auto&& iter : mImpl->mStringValueContainer)
{
- if ( iter.first == key )
+ if(iter.first == key)
{
return &iter.second;
}
}
- return NULL; // Not found
+ return nullptr; // Not found
}
-Property::Value* Property::Map::Find( const std::string& key ) const
+Property::Value* Property::Map::Find(const std::string& key) const
{
- return Find( key.c_str() );
+ return Find(key.c_str());
}
-Property::Value* Property::Map::Find( Property::Index key ) const
+Property::Value* Property::Map::Find(Property::Index key) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mIndexValueContainer )
+ for(auto&& iter : mImpl->mIndexValueContainer)
{
- if ( iter.first == key )
+ if(iter.first == key)
{
return &iter.second;
}
}
- return NULL; // Not found
+ return nullptr; // Not found
}
-Property::Value* Property::Map::Find( Property::Index indexKey, const std::string& stringKey ) const
+Property::Value* Property::Map::Find(Property::Index indexKey, const std::string& stringKey) const
{
- Property::Value* valuePtr = Find( indexKey );
- if( !valuePtr )
+ Property::Value* valuePtr = Find(indexKey);
+ if(!valuePtr)
{
- valuePtr = Find( stringKey );
+ valuePtr = Find(stringKey);
}
return valuePtr;
}
-Property::Value* Property::Map::Find( const std::string& key, Property::Type type ) const
+Property::Value* Property::Map::Find(const std::string& key, Property::Type type) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mStringValueContainer )
+ for(auto&& iter : mImpl->mStringValueContainer)
{
- if( (iter.second.GetType() == type) && (iter.first == key) )
+ if((iter.second.GetType() == type) && (iter.first == key))
{
return &iter.second;
}
}
- return NULL; // Not found
+ return nullptr; // Not found
}
-Property::Value* Property::Map::Find( Property::Index key, Property::Type type ) const
+Property::Value* Property::Map::Find(Property::Index key, Property::Type type) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mIndexValueContainer )
+ for(auto&& iter : mImpl->mIndexValueContainer)
{
- if( (iter.second.GetType() == type) && (iter.first == key) )
+ if((iter.second.GetType() == type) && (iter.first == key))
{
return &iter.second;
}
}
- return NULL; // Not found
+ return nullptr; // Not found
}
void Property::Map::Clear()
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
mImpl->mStringValueContainer.clear();
mImpl->mIndexValueContainer.clear();
}
-void Property::Map::Merge( const Property::Map& from )
+void Property::Map::Merge(const Property::Map& from)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
// Ensure we're not attempting to merge with ourself
- if ( this != &from )
+ if(this != &from)
{
- if ( Count() )
+ if(Count())
{
- for( auto&& iter : from.mImpl->mStringValueContainer )
+ for(auto&& iter : from.mImpl->mStringValueContainer)
{
(*this)[iter.first] = iter.second;
}
- for( auto&& iter : from.mImpl->mIndexValueContainer )
+ for(auto&& iter : from.mImpl->mIndexValueContainer)
{
(*this)[iter.first] = iter.second;
}
}
}
-const Property::Value& Property::Map::operator[]( const std::string& key ) const
+const Property::Value& Property::Map::operator[](const std::string& key) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mStringValueContainer )
+ for(auto&& iter : mImpl->mStringValueContainer)
{
- if ( iter.first == key )
+ if(iter.first == key)
{
return iter.second;
}
}
- DALI_ASSERT_ALWAYS( ! "Invalid Key" );
+ DALI_ASSERT_ALWAYS(!"Invalid Key");
}
-Property::Value& Property::Map::operator[]( const std::string& key )
+Property::Value& Property::Map::operator[](const std::string& key)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mStringValueContainer )
+ for(auto&& iter : mImpl->mStringValueContainer)
{
- if ( iter.first == key )
+ if(iter.first == key)
{
return iter.second;
}
}
// Create and return reference to new value
- mImpl->mStringValueContainer.push_back( std::make_pair( key, Property::Value() ) );
+ mImpl->mStringValueContainer.push_back(std::make_pair(key, Property::Value()));
return (mImpl->mStringValueContainer.end() - 1)->second;
}
-const Property::Value& Property::Map::operator[]( Property::Index key ) const
+const Property::Value& Property::Map::operator[](Property::Index key) const
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mIndexValueContainer )
+ for(auto&& iter : mImpl->mIndexValueContainer)
{
- if ( iter.first == key )
+ if(iter.first == key)
{
return iter.second;
}
}
- DALI_ASSERT_ALWAYS( ! "Invalid Key" );
+ DALI_ASSERT_ALWAYS(!"Invalid Key");
}
-Property::Value& Property::Map::operator[]( Property::Index key )
+Property::Value& Property::Map::operator[](Property::Index key)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- for( auto&& iter : mImpl->mIndexValueContainer )
+ for(auto&& iter : mImpl->mIndexValueContainer)
{
- if ( iter.first == key )
+ if(iter.first == key)
{
return iter.second;
}
}
// Create and return reference to new value
- mImpl->mIndexValueContainer.push_back( std::make_pair( key, Property::Value() ) );
+ mImpl->mIndexValueContainer.push_back(std::make_pair(key, Property::Value()));
return (mImpl->mIndexValueContainer.end() - 1)->second;
}
-Property::Map& Property::Map::operator=( const Property::Map& other )
+Property::Map& Property::Map::operator=(const Property::Map& other)
{
- DALI_ASSERT_DEBUG( mImpl && "Cannot use an object previously used as an r-value" );
+ DALI_ASSERT_DEBUG(mImpl && "Cannot use an object previously used as an r-value");
- if( this != &other )
+ if(this != &other)
{
mImpl->mStringValueContainer = other.mImpl->mStringValueContainer;
- mImpl->mIndexValueContainer = other.mImpl->mIndexValueContainer;
+ mImpl->mIndexValueContainer = other.mImpl->mIndexValueContainer;
}
return *this;
}
-Property::Map& Property::Map::operator=( Property::Map&& other )
+Property::Map& Property::Map::operator=(Property::Map&& other)
{
- if( this != &other )
+ if(this != &other)
{
delete mImpl;
- mImpl = other.mImpl;
+ mImpl = other.mImpl;
other.mImpl = nullptr;
}
return *this;
}
-std::ostream& operator<<( std::ostream& stream, const Property::Map& map )
+std::ostream& operator<<(std::ostream& stream, const Property::Map& map)
{
stream << "Map(" << map.Count() << ") = {";
- if ( map.mImpl )
+ if(map.mImpl)
{
int32_t count = 0;
// Output the String-Value pairs
- for( auto&& iter : map.mImpl->mStringValueContainer )
+ for(auto&& iter : map.mImpl->mStringValueContainer)
{
- if( count++ > 0 )
+ if(count++ > 0)
{
- stream<<", ";
+ stream << ", ";
}
- stream<< iter.first << ":" << iter.second;
+ stream << iter.first << ":" << iter.second;
}
// Output the Index-Value pairs
- for( auto&& iter : map.mImpl->mIndexValueContainer )
+ for(auto&& iter : map.mImpl->mIndexValueContainer)
{
- if( count++ > 0 )
+ if(count++ > 0)
{
- stream<<", ";
+ stream << ", ";
}
- stream<< iter.first << ":" << iter.second;
+ stream << iter.first << ":" << iter.second;
}
}
#define DALI_PROPERTY_MAP_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*/
// EXTERNAL INCLUDES
-#include <string>
-#include <sstream>
#include <initializer_list>
+#include <sstream>
+#include <string>
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
-#include <dali/public-api/object/property.h>
#include <dali/public-api/object/property-key.h>
#include <dali/public-api/object/property-value.h>
+#include <dali/public-api/object/property.h>
namespace Dali
{
* @{
*/
-typedef std::pair< Property::Key, Property::Value > KeyValuePair;
-typedef std::pair<std::string, Property::Value> StringValuePair;
+using KeyValuePair = std::pair<Property::Key, Property::Value>;
+using StringValuePair = std::pair<std::string, Property::Value>;
/**
* @brief A Map of property values, the key type could be String or Property::Index.
class DALI_CORE_API Property::Map
{
public:
-
- typedef std::size_t SizeType;
+ using SizeType = std::size_t;
/**
* @brief Default constructor.
* @SINCE_1_4.17
* @param[in] values An initializer_list of pairs of index and value.
*/
- Map( const std::initializer_list< KeyValuePair >& values );
+ Map(const std::initializer_list<KeyValuePair>& values);
/**
* @brief Copy constructor.
* @SINCE_1_0.0
* @param[in] other The Map to copy from
*/
- Map( const Map& other );
+ Map(const Map& other);
/**
* @brief Move constructor.
* @param[in] other The Map to move from
* @note After the @a other array is used, it becomes invalid and is no longer usable.
*/
- Map( Map&& other );
+ Map(Map&& other);
/**
* @brief Non-virtual destructor.
* @param[in] key The key to insert
* @param[in] value The value to insert
*/
- void Insert( const char* key, const Value& value );
+ void Insert(const char* key, const Value& value);
/**
* @brief Inserts the key-value pair in the Map, with the key type as string.
* @param[in] key The key to insert
* @param[in] value The value to insert
*/
- void Insert( const std::string& key, const Value& value );
+ void Insert(const std::string& key, const Value& value);
/**
* @brief Inserts the key-value pair in the Map, with the key type as index.
* @param[in] key The key to insert
* @param[in] value The value to insert
*/
- void Insert( Property::Index key, const Value& value );
-
+ void Insert(Property::Index key, const Value& value);
/**
* @brief Inserts the key-value pair in the Map, with the key type as string.
* @param value to insert
* @return a reference to this object
*/
- inline Property::Map& Add( const char* key, const Value& value )
+ inline Property::Map& Add(const char* key, const Value& value)
{
Insert(key, value);
return *this;
* @param value to insert
* @return a reference to this object
*/
- inline Property::Map& Add( const std::string& key, const Value& value )
+ inline Property::Map& Add(const std::string& key, const Value& value)
{
Insert(key, value);
return *this;
}
-
/**
* @brief Inserts the key-value pair in the Map, with the key type as index.
*
* @param value to insert
* @return a reference to this object
*/
- inline Property::Map& Add( Property::Index key, const Value& value )
+ inline Property::Map& Add(Property::Index key, const Value& value)
{
Insert(key, value);
return *this;
*
* @note Will assert if position >= Count()
*/
- Value& GetValue( SizeType position ) const;
+ Value& GetValue(SizeType position) const;
/**
* DEPRECATED_1_1.39 Position based retrieval is no longer supported after extending the key type to both Index and String.
*
* @note Will assert if position >= Count()
*/
- const std::string& GetKey( SizeType position ) const DALI_DEPRECATED_API;
+ const std::string& GetKey(SizeType position) const DALI_DEPRECATED_API;
/**
* @brief Retrieve the key at the specified position.
*
* @note Will assert if position >= Count()
*/
- Key GetKeyAt( SizeType position ) const;
+ Key GetKeyAt(SizeType position) const;
/**
* DEPRECATED_1_1.39 Position based retrieval is no longer supported after extending the key type to both Index and String.
*
* @note Will assert if position >= Count() or key at position is an index key.
*/
- StringValuePair& GetPair( SizeType position ) const DALI_DEPRECATED_API;
+ StringValuePair& GetPair(SizeType position) const DALI_DEPRECATED_API;
/**
* @brief Retrieve the key & the value at the specified position.
*
* @note Will assert if position >= Count()
*/
- KeyValuePair GetKeyValue( SizeType position ) const;
+ KeyValuePair GetKeyValue(SizeType position) const;
/**
* @brief Finds the value for the specified key if it exists.
*
* @return A const pointer to the value if it exists, NULL otherwise
*/
- Value* Find( const char* key ) const;
+ Value* Find(const char* key) const;
/**
* @brief Finds the value for the specified key if it exists.
*
* @return A const pointer to the value if it exists, NULL otherwise
*/
- Value* Find( const std::string& key ) const;
+ Value* Find(const std::string& key) const;
/**
* @brief Finds the value for the specified key if it exists.
*
* @return A const pointer to the value if it exists, NULL otherwise
*/
- Value* Find( Property::Index key ) const;
+ Value* Find(Property::Index key) const;
/**
* @brief Finds the value for the specified keys if either exist.
*
* @return A const pointer to the value if it exists, NULL otherwise
*/
- Value* Find( Property::Index indexKey, const std::string& stringKey ) const;
+ Value* Find(Property::Index indexKey, const std::string& stringKey) const;
/**
* @brief Finds the value for the specified key if it exists and its type is type.
*
* @return A const pointer to the value if it exists, NULL otherwise
*/
- Value* Find( const std::string& key, Property::Type type ) const;
+ Value* Find(const std::string& key, Property::Type type) const;
/**
* @brief Finds the value for the specified key if it exists and its type is type.
*
* @return A const pointer to the value if it exists, NULL otherwise
*/
- Value* Find( Property::Index key, Property::Type type ) const;
+ Value* Find(Property::Index key, Property::Type type) const;
/**
* @brief Clears the map.
* @SINCE_1_0.0
* @param[in] from The map to merge from
*/
- void Merge( const Map& from );
+ void Merge(const Map& from);
/**
* @brief Const operator to access element with the specified string key.
*
* @note Will assert if invalid-key is given.
*/
- const Value& operator[]( const std::string& key ) const;
+ const Value& operator[](const std::string& key) const;
/**
* @brief Operator to access the element with the specified string key.
*
* @note If an element with the key does not exist, then it is created.
*/
- Value& operator[]( const std::string& key );
+ Value& operator[](const std::string& key);
/**
* @brief Const operator to access element with the specified index key.
*
* @note Will assert if invalid-key is given.
*/
- const Value& operator[]( Property::Index key ) const;
+ const Value& operator[](Property::Index key) const;
/**
* @brief Operator to access the element with the specified index key.
*
* @note If an element with the key does not exist, then it is created.
*/
- Value& operator[]( Property::Index key );
+ Value& operator[](Property::Index key);
/**
* @brief Assignment operator.
*
* @return The copied map
*/
- Map& operator=( const Map& other );
+ Map& operator=(const Map& other);
/**
* @brief Move assignment operator.
*
* @note The other array is an r-value so becomes invalid and is no longer usable.
*/
- Map& operator=( Map&& other );
+ Map& operator=(Map&& other);
/**
* @brief Output to stream.
* @SINCE_1_1.28
*/
- friend DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Map& map );
+ friend DALI_CORE_API std::ostream& operator<<(std::ostream& stream, const Property::Map& map);
private:
- struct DALI_INTERNAL Impl; ///< Private data
- Impl* mImpl; ///< Pointer to private data
+ struct DALI_INTERNAL Impl; ///< Private data
+ Impl* mImpl; ///< Pointer to private data
};
/**
* @param[in] map The map to insert
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<<( std::ostream& stream, const Property::Map& map );
+DALI_CORE_API std::ostream& operator<<(std::ostream& stream, const Property::Map& map);
/**
* @}
#define DALI_PROPERTY_NOTIFICATION_DECLARATIONS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
*
*/
-
// INTERNAL INCLUDES
#include <dali/public-api/signals/dali-signal.h>
* @brief Signal type for Dali::PropertyNotification::NotifySignal().
* @SINCE_1_0.0
*/
-typedef Signal< void (PropertyNotification& source) > PropertyNotifySignalType;
+using PropertyNotifySignalType = Signal<void(PropertyNotification&)>;
/**
* @}
#include <dali/public-api/object/property-notification.h>
// INTERNAL INCLUDES
-#include <dali/public-api/math/quaternion.h>
+#include <dali/internal/event/common/property-notification-impl.h>
#include <dali/public-api/math/degree.h>
+#include <dali/public-api/math/quaternion.h>
#include <dali/public-api/math/radian.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/object/handle.h>
-#include <dali/internal/event/common/property-notification-impl.h>
#include <stdio.h>
namespace Dali
{
-
PropertyNotification::PropertyNotification()
{
}
{
}
-PropertyNotification PropertyNotification::DownCast( BaseHandle handle )
+PropertyNotification PropertyNotification::DownCast(BaseHandle handle)
{
- return PropertyNotification( dynamic_cast<Dali::Internal::PropertyNotification*>(handle.GetObjectPtr()) );
+ return PropertyNotification(dynamic_cast<Dali::Internal::PropertyNotification*>(handle.GetObjectPtr()));
}
PropertyNotification::~PropertyNotification()
PropertyNotification& PropertyNotification::operator=(const PropertyNotification& rhs) = default;
-PropertyNotification::PropertyNotification( PropertyNotification&& rhs ) = default;
+PropertyNotification::PropertyNotification(PropertyNotification&& rhs) = default;
-PropertyNotification& PropertyNotification::operator=( PropertyNotification&& rhs ) = default;
+PropertyNotification& PropertyNotification::operator=(PropertyNotification&& rhs) = default;
PropertyCondition PropertyNotification::GetCondition()
{
return GetImplementation(*this).GetTargetProperty();
}
-void PropertyNotification::SetNotifyMode( NotifyMode mode )
+void PropertyNotification::SetNotifyMode(NotifyMode mode)
{
- GetImplementation(*this).SetNotifyMode( mode );
+ GetImplementation(*this).SetNotifyMode(mode);
}
PropertyNotification::NotifyMode PropertyNotification::GetNotifyMode()
// INTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
-#include <dali/public-api/object/property-notification-declarations.h>
#include <dali/public-api/object/property-conditions.h>
+#include <dali/public-api/object/property-notification-declarations.h>
#include <dali/public-api/object/property.h>
namespace Dali
*/
enum NotifyMode
{
- DISABLED, ///< Don't notify, regardless of result of Condition @SINCE_1_9.28
- NOTIFY_ON_TRUE, ///< Notify whenever condition changes from false to true. @SINCE_1_9.28
- NOTIFY_ON_FALSE, ///< Notify whenever condition changes from true to false. @SINCE_1_9.28
- NOTIFY_ON_CHANGED ///< Notify whenever condition changes (false to true, and true to false) @SINCE_1_9.28
+ DISABLED, ///< Don't notify, regardless of result of Condition @SINCE_1_9.28
+ NOTIFY_ON_TRUE, ///< Notify whenever condition changes from false to true. @SINCE_1_9.28
+ NOTIFY_ON_FALSE, ///< Notify whenever condition changes from true to false. @SINCE_1_9.28
+ NOTIFY_ON_CHANGED ///< Notify whenever condition changes (false to true, and true to false) @SINCE_1_9.28
};
public:
-
/**
* @brief Creates an uninitialized PropertyNotification; this can be initialized with PropertyNotification::New().
*
* @param[in] handle to An object
* @return handle to a PropertyNotification object or an uninitialized handle
*/
- static PropertyNotification DownCast( BaseHandle handle );
+ static PropertyNotification DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- PropertyNotification( PropertyNotification&& rhs );
+ PropertyNotification(PropertyNotification&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- PropertyNotification& operator=( PropertyNotification&& rhs );
+ PropertyNotification& operator=(PropertyNotification&& rhs);
/**
* @brief Gets the condition of this notification.
* @SINCE_1_0.0
* @param[in] mode Notification mode (Default is PropertyNotification::NOTIFY_ON_TRUE)
*/
- void SetNotifyMode( NotifyMode mode );
+ void SetNotifyMode(NotifyMode mode);
/**
* @brief Retrieves the current Notification mode.
PropertyNotifySignalType& NotifySignal();
public: // Not intended for use by Application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali New() methods.
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
namespace
{
-const char* const PROPERTY_TYPE_NAMES[] =
-{
+const char* const PROPERTY_TYPE_NAMES[] = {
"NONE",
"BOOLEAN",
"FLOAT",
"MAP",
"EXTENTS",
};
-const uint32_t PROPERTY_TYPE_NAMES_COUNT = static_cast<uint32_t>( sizeof( PROPERTY_TYPE_NAMES ) / sizeof( const char* ) );
-}
+const uint32_t PROPERTY_TYPE_NAMES_COUNT = static_cast<uint32_t>(sizeof(PROPERTY_TYPE_NAMES) / sizeof(const char*));
+} // namespace
namespace PropertyTypes
{
-
DALI_CORE_API const char* GetName(Property::Type type)
{
- if (type < PROPERTY_TYPE_NAMES_COUNT )
+ if(type < PROPERTY_TYPE_NAMES_COUNT)
{
return PROPERTY_TYPE_NAMES[type];
}
#define DALI_PROPERTY_TYPES_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/common/extents.h>
#include <dali/public-api/math/angle-axis.h>
#include <dali/public-api/math/degree.h>
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/matrix3.h>
#include <dali/public-api/math/quaternion.h>
+#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/matrix3.h>
-#include <dali/public-api/math/matrix.h>
-#include <dali/public-api/math/rect.h>
#include <dali/public-api/object/property.h>
namespace Dali
*/
namespace PropertyTypes
{
-
/**
* @brief Retrieves the name of a property type.
*
* @SINCE_1_0.0
* @return The property type
*/
-template <typename T>
-inline Property::Type Get() { return Property::NONE; }
-template <>
-inline Property::Type Get<bool>() { return Property::BOOLEAN; }
-template <>
-inline Property::Type Get<float>() { return Property::FLOAT; }
-template <>
-inline Property::Type Get<int>() { return Property::INTEGER; }
-template <>
-inline Property::Type Get<Vector2>() { return Property::VECTOR2; }
-template <>
-inline Property::Type Get<Vector3>() { return Property::VECTOR3; }
-template <>
-inline Property::Type Get<Vector4>() { return Property::VECTOR4; }
-template <>
-inline Property::Type Get<Matrix3>() { return Property::MATRIX3; }
-template <>
-inline Property::Type Get<Matrix>() { return Property::MATRIX; }
-template <>
-inline Property::Type Get<AngleAxis>() { return Property::ROTATION; } // Rotation has two representations
-template <>
-inline Property::Type Get<Quaternion>() { return Property::ROTATION; } // Rotation has two representations
-template <>
-inline Property::Type Get<std::string>() { return Property::STRING; }
-template <>
-inline Property::Type Get<Dali::Rect<int> >() { return Property::RECTANGLE; }
-template <>
-inline Property::Type Get<Property::Map>() { return Property::MAP; }
-template <>
-inline Property::Type Get<Property::Array>() { return Property::ARRAY; }
-template <>
-inline Property::Type Get<Extents>() { return Property::EXTENTS; }
-
+template<typename T>
+inline Property::Type Get()
+{
+ return Property::NONE;
+}
+template<>
+inline Property::Type Get<bool>()
+{
+ return Property::BOOLEAN;
+}
+template<>
+inline Property::Type Get<float>()
+{
+ return Property::FLOAT;
+}
+template<>
+inline Property::Type Get<int>()
+{
+ return Property::INTEGER;
+}
+template<>
+inline Property::Type Get<Vector2>()
+{
+ return Property::VECTOR2;
+}
+template<>
+inline Property::Type Get<Vector3>()
+{
+ return Property::VECTOR3;
+}
+template<>
+inline Property::Type Get<Vector4>()
+{
+ return Property::VECTOR4;
+}
+template<>
+inline Property::Type Get<Matrix3>()
+{
+ return Property::MATRIX3;
+}
+template<>
+inline Property::Type Get<Matrix>()
+{
+ return Property::MATRIX;
+}
+template<>
+inline Property::Type Get<AngleAxis>()
+{
+ return Property::ROTATION;
+} // Rotation has two representations
+template<>
+inline Property::Type Get<Quaternion>()
+{
+ return Property::ROTATION;
+} // Rotation has two representations
+template<>
+inline Property::Type Get<std::string>()
+{
+ return Property::STRING;
+}
+template<>
+inline Property::Type Get<Dali::Rect<int> >()
+{
+ return Property::RECTANGLE;
+}
+template<>
+inline Property::Type Get<Property::Map>()
+{
+ return Property::MAP;
+}
+template<>
+inline Property::Type Get<Property::Array>()
+{
+ return Property::ARRAY;
+}
+template<>
+inline Property::Type Get<Extents>()
+{
+ return Property::EXTENTS;
+}
}; // namespace PropertyTypes
#include <ostream>
// INTERNAL INCLUDES
+#include <dali/integration-api/debug.h>
#include <dali/public-api/common/extents.h>
#include <dali/public-api/math/angle-axis.h>
+#include <dali/public-api/math/matrix.h>
+#include <dali/public-api/math/matrix3.h>
+#include <dali/public-api/math/quaternion.h>
#include <dali/public-api/math/radian.h>
+#include <dali/public-api/math/rect.h>
#include <dali/public-api/math/vector2.h>
#include <dali/public-api/math/vector3.h>
#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/matrix3.h>
-#include <dali/public-api/math/matrix.h>
-#include <dali/public-api/math/rect.h>
-#include <dali/public-api/math/quaternion.h>
-#include <dali/public-api/object/property-map.h>
#include <dali/public-api/object/property-array.h>
+#include <dali/public-api/object/property-map.h>
#include <dali/public-api/object/property-types.h>
-#include <dali/integration-api/debug.h>
namespace Dali
{
-
namespace
{
/**
* Helper to check if the property value can be read as int/bool
*/
-inline bool IsIntegerType( Property::Type type )
+inline bool IsIntegerType(Property::Type type)
{
- return ( Property::BOOLEAN == type )||( Property::INTEGER == type );
-}
+ return (Property::BOOLEAN == type) || (Property::INTEGER == type);
}
+} // namespace
struct Property::Value::Impl
{
- Impl( bool booleanValue )
- : type( Property::BOOLEAN ),
- integerValue( booleanValue )
- { }
+ Impl(bool booleanValue)
+ : type(Property::BOOLEAN),
+ integerValue(booleanValue)
+ {
+ }
- Impl( float floatValue )
- : type( Property::FLOAT ),
- floatValue( floatValue )
- { }
+ Impl(float floatValue)
+ : type(Property::FLOAT),
+ floatValue(floatValue)
+ {
+ }
- Impl( int32_t integerValue )
- : type( Property::INTEGER ),
- integerValue( integerValue )
- { }
+ Impl(int32_t integerValue)
+ : type(Property::INTEGER),
+ integerValue(integerValue)
+ {
+ }
- Impl( const Vector2& vectorValue )
- : type( Property::VECTOR2 ),
- vector2Value( new Vector2( vectorValue ) )
- { }
+ Impl(const Vector2& vectorValue)
+ : type(Property::VECTOR2),
+ vector2Value(new Vector2(vectorValue))
+ {
+ }
- Impl( const Vector3& vectorValue )
- : type( Property::VECTOR3 ),
- vector3Value( new Vector3( vectorValue ) )
- { }
+ Impl(const Vector3& vectorValue)
+ : type(Property::VECTOR3),
+ vector3Value(new Vector3(vectorValue))
+ {
+ }
- Impl( const Vector4& vectorValue )
- : type( Property::VECTOR4 ),
- vector4Value( new Vector4( vectorValue ) )
- { }
+ Impl(const Vector4& vectorValue)
+ : type(Property::VECTOR4),
+ vector4Value(new Vector4(vectorValue))
+ {
+ }
- Impl( const Matrix3& matrixValue )
- : type( Property::MATRIX3 ),
- matrix3Value( new Matrix3( matrixValue ) )
+ Impl(const Matrix3& matrixValue)
+ : type(Property::MATRIX3),
+ matrix3Value(new Matrix3(matrixValue))
{
}
- Impl( const Matrix& matrixValue )
- : type( Property::MATRIX ),
- matrixValue( new Matrix( matrixValue ) )
+ Impl(const Matrix& matrixValue)
+ : type(Property::MATRIX),
+ matrixValue(new Matrix(matrixValue))
{
}
- Impl( const AngleAxis& angleAxisValue )
- : type( Property::ROTATION ),
- angleAxisValue( new AngleAxis(angleAxisValue) )
+ Impl(const AngleAxis& angleAxisValue)
+ : type(Property::ROTATION),
+ angleAxisValue(new AngleAxis(angleAxisValue))
{
}
- Impl( const Quaternion& quaternionValue )
- : type( Property::ROTATION ),
- angleAxisValue( new AngleAxis() )
+ Impl(const Quaternion& quaternionValue)
+ : type(Property::ROTATION),
+ angleAxisValue(new AngleAxis())
{
- quaternionValue.ToAxisAngle( angleAxisValue->axis, angleAxisValue->angle );
+ quaternionValue.ToAxisAngle(angleAxisValue->axis, angleAxisValue->angle);
}
- Impl( const std::string& stringValue )
- : type( Property::STRING ),
- stringValue( new std::string( stringValue ) )
+ Impl(const std::string& stringValue)
+ : type(Property::STRING),
+ stringValue(new std::string(stringValue))
{
}
- Impl( const Rect<int32_t>& rectValue )
- : type( Property::RECTANGLE ),
- rectValue( new Rect<int>( rectValue ) )
+ Impl(const Rect<int32_t>& rectValue)
+ : type(Property::RECTANGLE),
+ rectValue(new Rect<int>(rectValue))
{
}
- Impl( const Rect<float>& rectValue )
- : type( Property::VECTOR4 ),
- vector4Value( new Vector4( rectValue.x, rectValue.y, rectValue.width, rectValue.height ) )
+ Impl(const Rect<float>& rectValue)
+ : type(Property::VECTOR4),
+ vector4Value(new Vector4(rectValue.x, rectValue.y, rectValue.width, rectValue.height))
{
}
- Impl( const Property::Array& arrayValue )
- : type( Property::ARRAY ),
- arrayValue( new Property::Array( arrayValue ) )
+ Impl(const Property::Array& arrayValue)
+ : type(Property::ARRAY),
+ arrayValue(new Property::Array(arrayValue))
{
}
- Impl( Property::Array&& arrayValue )
- : type( Property::ARRAY ),
- arrayValue( new Property::Array( std::move( arrayValue ) ) )
+ Impl(Property::Array&& arrayValue)
+ : type(Property::ARRAY),
+ arrayValue(new Property::Array(std::move(arrayValue)))
{
}
- Impl( const Property::Map& mapValue )
- : type( Property::MAP ),
- mapValue( new Property::Map( mapValue ) )
+ Impl(const Property::Map& mapValue)
+ : type(Property::MAP),
+ mapValue(new Property::Map(mapValue))
{
}
- Impl( Property::Map&& mapValue )
- : type( Property::MAP ),
- mapValue( new Property::Map( std::move( mapValue ) ) )
+ Impl(Property::Map&& mapValue)
+ : type(Property::MAP),
+ mapValue(new Property::Map(std::move(mapValue)))
{
}
- Impl( const Extents& extentsValue )
- : type( Property::EXTENTS ),
- extentsValue( new Extents( extentsValue ) )
+ Impl(const Extents& extentsValue)
+ : type(Property::EXTENTS),
+ extentsValue(new Extents(extentsValue))
{
}
- Impl( const std::initializer_list< KeyValuePair >& values )
- : type( Property::MAP ),
- mapValue( new Property::Map( values ) )
+ Impl(const std::initializer_list<KeyValuePair>& values)
+ : type(Property::MAP),
+ mapValue(new Property::Map(values))
{
}
*/
~Impl()
{
- switch( type )
+ switch(type)
{
- case Property::NONE : // FALLTHROUGH
- case Property::BOOLEAN : // FALLTHROUGH
- case Property::FLOAT : // FALLTHROUGH
- case Property::INTEGER :
+ case Property::NONE: // FALLTHROUGH
+ case Property::BOOLEAN: // FALLTHROUGH
+ case Property::FLOAT: // FALLTHROUGH
+ case Property::INTEGER:
{
break; // nothing to do
}
- case Property::VECTOR2 :
+ case Property::VECTOR2:
{
delete vector2Value;
break;
}
public: // Data
-
Type type;
union
{
int32_t integerValue;
- float floatValue;
+ float floatValue;
// must use pointers for any class value pre c++ 11
- Vector2* vector2Value;
- Vector3* vector3Value;
- Vector4* vector4Value;
- Matrix3* matrix3Value;
- Matrix* matrixValue;
- AngleAxis* angleAxisValue;
- std::string* stringValue;
- Rect<int32_t>* rectValue;
+ Vector2* vector2Value;
+ Vector3* vector3Value;
+ Vector4* vector4Value;
+ Matrix3* matrix3Value;
+ Matrix* matrixValue;
+ AngleAxis* angleAxisValue;
+ std::string* stringValue;
+ Rect<int32_t>* rectValue;
Property::Array* arrayValue;
- Property::Map* mapValue;
- Extents* extentsValue;
+ Property::Map* mapValue;
+ Extents* extentsValue;
};
private:
-
// non-copyable
- Impl( const Impl& ) = delete;
- Impl& operator=( const Impl& ) = delete;
-
+ Impl(const Impl&) = delete;
+ Impl& operator=(const Impl&) = delete;
};
Property::Value::Value()
-: mImpl( nullptr )
+: mImpl(nullptr)
{
}
-Property::Value::Value( bool booleanValue )
-: mImpl( new Impl( booleanValue ) )
+Property::Value::Value(bool booleanValue)
+: mImpl(new Impl(booleanValue))
{
}
-Property::Value::Value( float floatValue )
-: mImpl( new Impl( floatValue ) )
+Property::Value::Value(float floatValue)
+: mImpl(new Impl(floatValue))
{
}
-Property::Value::Value( int32_t integerValue )
-: mImpl( new Impl( integerValue ) )
+Property::Value::Value(int32_t integerValue)
+: mImpl(new Impl(integerValue))
{
}
-Property::Value::Value( const Vector2& vectorValue )
-: mImpl( new Impl( vectorValue ) )
+Property::Value::Value(const Vector2& vectorValue)
+: mImpl(new Impl(vectorValue))
{
}
-Property::Value::Value( const Vector3& vectorValue )
-: mImpl( new Impl( vectorValue ) )
+Property::Value::Value(const Vector3& vectorValue)
+: mImpl(new Impl(vectorValue))
{
}
-Property::Value::Value( const Vector4& vectorValue )
-: mImpl( new Impl( vectorValue ) )
+Property::Value::Value(const Vector4& vectorValue)
+: mImpl(new Impl(vectorValue))
{
}
-Property::Value::Value( const Matrix3& matrixValue )
-: mImpl( new Impl( matrixValue ) )
+Property::Value::Value(const Matrix3& matrixValue)
+: mImpl(new Impl(matrixValue))
{
}
-Property::Value::Value( const Matrix& matrixValue )
-: mImpl( new Impl( matrixValue ) )
+Property::Value::Value(const Matrix& matrixValue)
+: mImpl(new Impl(matrixValue))
{
}
-Property::Value::Value( const Rect<int32_t>& rectValue )
-: mImpl( new Impl( rectValue ) )
+Property::Value::Value(const Rect<int32_t>& rectValue)
+: mImpl(new Impl(rectValue))
{
}
-Property::Value::Value( const Rect<float>& rectValue )
-: mImpl( new Impl( rectValue ) )
+Property::Value::Value(const Rect<float>& rectValue)
+: mImpl(new Impl(rectValue))
{
}
-Property::Value::Value( const AngleAxis& angleAxisValue )
-: mImpl( new Impl( angleAxisValue ) )
+Property::Value::Value(const AngleAxis& angleAxisValue)
+: mImpl(new Impl(angleAxisValue))
{
}
-Property::Value::Value( const Quaternion& quaternionValue )
-: mImpl( new Impl( quaternionValue ) )
+Property::Value::Value(const Quaternion& quaternionValue)
+: mImpl(new Impl(quaternionValue))
{
}
-Property::Value::Value( const std::string& stringValue )
-: mImpl( new Impl( stringValue ) )
+Property::Value::Value(const std::string& stringValue)
+: mImpl(new Impl(stringValue))
{
}
-Property::Value::Value( const char* stringValue )
-: mImpl( nullptr )
+Property::Value::Value(const char* stringValue)
+: mImpl(nullptr)
{
- if( stringValue ) // string constructor is undefined with nullptr
+ if(stringValue) // string constructor is undefined with nullptr
{
- mImpl = new Impl( std::string(stringValue) );
+ mImpl = new Impl(std::string(stringValue));
}
else
{
- mImpl = new Impl( std::string() );
+ mImpl = new Impl(std::string());
}
}
-Property::Value::Value( Property::Array& arrayValue )
-: mImpl( new Impl( arrayValue ) )
+Property::Value::Value(Property::Array& arrayValue)
+: mImpl(new Impl(arrayValue))
{
}
-Property::Value::Value( Property::Array&& arrayValue )
-: mImpl( new Impl( std::move( arrayValue ) ) )
+Property::Value::Value(Property::Array&& arrayValue)
+: mImpl(new Impl(std::move(arrayValue)))
{
}
-Property::Value::Value( Property::Map& mapValue )
-: mImpl( new Impl( mapValue ) )
+Property::Value::Value(Property::Map& mapValue)
+: mImpl(new Impl(mapValue))
{
}
-Property::Value::Value( Property::Map&& mapValue )
-: mImpl( new Impl( std::move( mapValue ) ) )
+Property::Value::Value(Property::Map&& mapValue)
+: mImpl(new Impl(std::move(mapValue)))
{
}
-Property::Value::Value( const Extents& extentsValue )
-: mImpl( new Impl( extentsValue ) )
+Property::Value::Value(const Extents& extentsValue)
+: mImpl(new Impl(extentsValue))
{
}
-Property::Value::Value( const std::initializer_list< KeyValuePair >& values )
-: mImpl( new Impl( values ) )
+Property::Value::Value(const std::initializer_list<KeyValuePair>& values)
+: mImpl(new Impl(values))
{
}
-Property::Value::Value( Type type )
-: mImpl( nullptr )
+Property::Value::Value(Type type)
+: mImpl(nullptr)
{
- switch (type)
+ switch(type)
{
case Property::BOOLEAN:
{
- mImpl = new Impl( false );
+ mImpl = new Impl(false);
break;
}
case Property::FLOAT:
{
- mImpl = new Impl( 0.f );
+ mImpl = new Impl(0.f);
break;
}
case Property::INTEGER:
{
- mImpl = new Impl( 0 );
+ mImpl = new Impl(0);
break;
}
case Property::VECTOR2:
{
- mImpl = new Impl( Vector2::ZERO );
+ mImpl = new Impl(Vector2::ZERO);
break;
}
case Property::VECTOR3:
{
- mImpl = new Impl( Vector3::ZERO );
+ mImpl = new Impl(Vector3::ZERO);
break;
}
case Property::VECTOR4:
{
- mImpl = new Impl( Vector4::ZERO );
+ mImpl = new Impl(Vector4::ZERO);
break;
}
case Property::RECTANGLE:
{
- mImpl = new Impl( Rect<int32_t>(0,0,0,0) );
+ mImpl = new Impl(Rect<int32_t>(0, 0, 0, 0));
break;
}
case Property::ROTATION:
{
- mImpl = new Impl( AngleAxis() );
+ mImpl = new Impl(AngleAxis());
break;
}
case Property::STRING:
{
- mImpl = new Impl( std::string() );
+ mImpl = new Impl(std::string());
break;
}
case Property::MATRIX:
{
- mImpl = new Impl( Matrix() );
+ mImpl = new Impl(Matrix());
break;
}
case Property::MATRIX3:
{
- mImpl = new Impl( Matrix3() );
+ mImpl = new Impl(Matrix3());
break;
}
case Property::ARRAY:
{
- mImpl = new Impl( Property::Array() );
+ mImpl = new Impl(Property::Array());
break;
}
case Property::MAP:
{
- mImpl = new Impl( Property::Map() );
+ mImpl = new Impl(Property::Map());
break;
}
case Property::EXTENTS:
{
- mImpl = new Impl( Extents() );
+ mImpl = new Impl(Extents());
break;
}
case Property::NONE:
}
}
-Property::Value::Value( const Property::Value& value )
-: mImpl( nullptr )
+Property::Value::Value(const Property::Value& value)
+: mImpl(nullptr)
{
// reuse assignment operator
- operator=( value );
+ operator=(value);
}
-Property::Value::Value( Property::Value&& value )
-: mImpl( value.mImpl )
+Property::Value::Value(Property::Value&& value)
+: mImpl(value.mImpl)
{
value.mImpl = nullptr;
}
-Property::Value& Property::Value::operator=( const Property::Value& value )
+Property::Value& Property::Value::operator=(const Property::Value& value)
{
- if ( this == &value )
+ if(this == &value)
{
// skip self assignment
return *this;
}
// if we are assigned an empty value, just drop impl
- if( !value.mImpl )
+ if(!value.mImpl)
{
delete mImpl;
mImpl = nullptr;
return *this;
}
// first check if the type is the same, no need to change impl, just assign
- if( mImpl && ( mImpl->type == value.mImpl->type ) )
+ if(mImpl && (mImpl->type == value.mImpl->type))
{
- switch( mImpl->type )
+ switch(mImpl->type)
{
case Property::BOOLEAN:
{
else
{
// different type, release old impl and create new
- Impl* newImpl( nullptr );
- switch ( value.mImpl->type )
+ Impl* newImpl(nullptr);
+ switch(value.mImpl->type)
{
case Property::BOOLEAN:
{
- newImpl = new Impl( bool( value.mImpl->integerValue ) );
+ newImpl = new Impl(bool(value.mImpl->integerValue));
break;
}
case Property::FLOAT:
{
- newImpl = new Impl( value.mImpl->floatValue );
+ newImpl = new Impl(value.mImpl->floatValue);
break;
}
case Property::INTEGER:
{
- newImpl = new Impl( value.mImpl->integerValue );
+ newImpl = new Impl(value.mImpl->integerValue);
break;
}
case Property::VECTOR2:
{
- newImpl = new Impl( *value.mImpl->vector2Value ); // type cannot change in mImpl so vector is allocated
+ newImpl = new Impl(*value.mImpl->vector2Value); // type cannot change in mImpl so vector is allocated
break;
}
case Property::VECTOR3:
{
- newImpl = new Impl( *value.mImpl->vector3Value ); // type cannot change in mImpl so vector is allocated
+ newImpl = new Impl(*value.mImpl->vector3Value); // type cannot change in mImpl so vector is allocated
break;
}
case Property::VECTOR4:
{
- newImpl = new Impl( *value.mImpl->vector4Value ); // type cannot change in mImpl so vector is allocated
+ newImpl = new Impl(*value.mImpl->vector4Value); // type cannot change in mImpl so vector is allocated
break;
}
case Property::RECTANGLE:
{
- newImpl = new Impl( *value.mImpl->rectValue ); // type cannot change in mImpl so rect is allocated
+ newImpl = new Impl(*value.mImpl->rectValue); // type cannot change in mImpl so rect is allocated
break;
}
case Property::ROTATION:
{
- newImpl = new Impl( *value.mImpl->angleAxisValue ); // type cannot change in mImpl so quaternion is allocated
+ newImpl = new Impl(*value.mImpl->angleAxisValue); // type cannot change in mImpl so quaternion is allocated
break;
}
case Property::MATRIX3:
{
- newImpl = new Impl( *value.mImpl->matrix3Value ); // type cannot change in mImpl so matrix is allocated
+ newImpl = new Impl(*value.mImpl->matrix3Value); // type cannot change in mImpl so matrix is allocated
break;
}
case Property::MATRIX:
{
- newImpl = new Impl( *value.mImpl->matrixValue ); // type cannot change in mImpl so matrix is allocated
+ newImpl = new Impl(*value.mImpl->matrixValue); // type cannot change in mImpl so matrix is allocated
break;
}
case Property::STRING:
{
- newImpl = new Impl( *value.mImpl->stringValue ); // type cannot change in mImpl so string is allocated
+ newImpl = new Impl(*value.mImpl->stringValue); // type cannot change in mImpl so string is allocated
break;
}
case Property::ARRAY:
{
- newImpl = new Impl( *value.mImpl->arrayValue ); // type cannot change in mImpl so array is allocated
+ newImpl = new Impl(*value.mImpl->arrayValue); // type cannot change in mImpl so array is allocated
break;
}
case Property::MAP:
{
- newImpl = new Impl( *value.mImpl->mapValue ); // type cannot change in mImpl so map is allocated
+ newImpl = new Impl(*value.mImpl->mapValue); // type cannot change in mImpl so map is allocated
break;
}
case Property::EXTENTS:
{
- newImpl = new Impl( *value.mImpl->extentsValue ); // type cannot change in mImpl so extents is allocated
+ newImpl = new Impl(*value.mImpl->extentsValue); // type cannot change in mImpl so extents is allocated
break;
}
case Property::NONE:
return *this;
}
-Property::Value& Property::Value::operator=( Property::Value&& value )
+Property::Value& Property::Value::operator=(Property::Value&& value)
{
- if( this != &value )
+ if(this != &value)
{
delete mImpl;
- mImpl = value.mImpl;
+ mImpl = value.mImpl;
value.mImpl = nullptr;
}
Property::Type Property::Value::GetType() const
{
- Property::Type type( Property::NONE );
- if( mImpl )
+ Property::Type type(Property::NONE);
+ if(mImpl)
{
type = mImpl->type;
}
return type;
}
-bool Property::Value::Get( bool& booleanValue ) const
+bool Property::Value::Get(bool& booleanValue) const
{
bool converted = false;
- if( mImpl && IsIntegerType( mImpl->type ) )
+ if(mImpl && IsIntegerType(mImpl->type))
{
booleanValue = mImpl->integerValue;
- converted = true;
+ converted = true;
}
return converted;
}
-bool Property::Value::Get( float& floatValue ) const
+bool Property::Value::Get(float& floatValue) const
{
bool converted = false;
- if( mImpl )
+ if(mImpl)
{
- if( mImpl->type == FLOAT )
+ if(mImpl->type == FLOAT)
{
floatValue = mImpl->floatValue;
- converted = true;
+ converted = true;
}
- else if( IsIntegerType( mImpl->type ) )
+ else if(IsIntegerType(mImpl->type))
{
- floatValue = static_cast< float >( mImpl->integerValue );
- converted = true;
+ floatValue = static_cast<float>(mImpl->integerValue);
+ converted = true;
}
}
return converted;
}
-bool Property::Value::Get( int32_t& integerValue ) const
+bool Property::Value::Get(int32_t& integerValue) const
{
bool converted = false;
- if( mImpl )
+ if(mImpl)
{
- if( IsIntegerType( mImpl->type ) )
+ if(IsIntegerType(mImpl->type))
{
integerValue = mImpl->integerValue;
- converted = true;
+ converted = true;
}
- else if( mImpl->type == FLOAT )
+ else if(mImpl->type == FLOAT)
{
- integerValue = static_cast< int32_t >( mImpl->floatValue );
- converted = true;
+ integerValue = static_cast<int32_t>(mImpl->floatValue);
+ converted = true;
}
}
return converted;
}
-bool Property::Value::Get( Vector2& vectorValue ) const
+bool Property::Value::Get(Vector2& vectorValue) const
{
bool converted = false;
- if( mImpl )
+ if(mImpl)
{
// type cannot change in mImpl so vector is allocated
- if( mImpl->type == VECTOR2 || mImpl->type == VECTOR3 || mImpl->type == VECTOR4 )
+ if(mImpl->type == VECTOR2 || mImpl->type == VECTOR3 || mImpl->type == VECTOR4)
{
vectorValue = *(mImpl->vector2Value); // if Vector3 or 4 only x and y are assigned
- converted = true;
+ converted = true;
}
}
return converted;
}
-bool Property::Value::Get( Vector3& vectorValue ) const
+bool Property::Value::Get(Vector3& vectorValue) const
{
bool converted = false;
- if( mImpl )
+ if(mImpl)
{
// type cannot change in mImpl so vector is allocated
- if ( mImpl->type == VECTOR3 || mImpl->type == VECTOR4 )
+ if(mImpl->type == VECTOR3 || mImpl->type == VECTOR4)
{
vectorValue = *(mImpl->vector3Value); // if Vector4 only x,y,z are assigned
- converted = true;
+ converted = true;
}
- else if( mImpl->type == VECTOR2 )
+ else if(mImpl->type == VECTOR2)
{
vectorValue = *(mImpl->vector2Value);
- converted = true;
+ converted = true;
}
}
return converted;
}
-bool Property::Value::Get( Vector4& vectorValue ) const
+bool Property::Value::Get(Vector4& vectorValue) const
{
bool converted = false;
- if( mImpl )
+ if(mImpl)
{
- if( mImpl->type == VECTOR4 ) // type cannot change in mImpl so vector is allocated
+ if(mImpl->type == VECTOR4) // type cannot change in mImpl so vector is allocated
{
vectorValue = *(mImpl->vector4Value);
- converted = true;
+ converted = true;
}
- else if( mImpl->type == VECTOR2 )
+ else if(mImpl->type == VECTOR2)
{
vectorValue = *(mImpl->vector2Value);
- converted = true;
+ converted = true;
}
- else if( mImpl->type == VECTOR3 )
+ else if(mImpl->type == VECTOR3)
{
vectorValue = *(mImpl->vector3Value);
- converted = true;
+ converted = true;
}
}
return converted;
}
-bool Property::Value::Get( Matrix3& matrixValue ) const
+bool Property::Value::Get(Matrix3& matrixValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == MATRIX3) ) // type cannot change in mImpl so matrix is allocated
+ if(mImpl && (mImpl->type == MATRIX3)) // type cannot change in mImpl so matrix is allocated
{
matrixValue = *(mImpl->matrix3Value);
- converted = true;
+ converted = true;
}
return converted;
}
-bool Property::Value::Get( Matrix& matrixValue ) const
+bool Property::Value::Get(Matrix& matrixValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == MATRIX) ) // type cannot change in mImpl so matrix is allocated
+ if(mImpl && (mImpl->type == MATRIX)) // type cannot change in mImpl so matrix is allocated
{
matrixValue = *(mImpl->matrixValue);
- converted = true;
+ converted = true;
}
return converted;
}
-bool Property::Value::Get( Rect<int32_t>& rectValue ) const
+bool Property::Value::Get(Rect<int32_t>& rectValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == RECTANGLE) ) // type cannot change in mImpl so rect is allocated
+ if(mImpl && (mImpl->type == RECTANGLE)) // type cannot change in mImpl so rect is allocated
{
rectValue = *(mImpl->rectValue);
converted = true;
return converted;
}
-bool Property::Value::Get( AngleAxis& angleAxisValue ) const
+bool Property::Value::Get(AngleAxis& angleAxisValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == ROTATION) ) // type cannot change in mImpl so angleAxis is allocated
+ if(mImpl && (mImpl->type == ROTATION)) // type cannot change in mImpl so angleAxis is allocated
{
angleAxisValue = *(mImpl->angleAxisValue);
- converted = true;
+ converted = true;
}
return converted;
}
-bool Property::Value::Get( Quaternion& quaternionValue ) const
+bool Property::Value::Get(Quaternion& quaternionValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == ROTATION) ) // type cannot change in mImpl so angleAxis is allocated
+ if(mImpl && (mImpl->type == ROTATION)) // type cannot change in mImpl so angleAxis is allocated
{
- quaternionValue = Quaternion(mImpl->angleAxisValue->angle, mImpl->angleAxisValue->axis );
- converted = true;
+ quaternionValue = Quaternion(mImpl->angleAxisValue->angle, mImpl->angleAxisValue->axis);
+ converted = true;
}
return converted;
}
-bool Property::Value::Get( std::string& stringValue ) const
+bool Property::Value::Get(std::string& stringValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == STRING) ) // type cannot change in mImpl so string is allocated
+ if(mImpl && (mImpl->type == STRING)) // type cannot change in mImpl so string is allocated
{
- stringValue.assign( *(mImpl->stringValue) );
+ stringValue.assign(*(mImpl->stringValue));
converted = true;
}
return converted;
}
-bool Property::Value::Get( Property::Array& arrayValue ) const
+bool Property::Value::Get(Property::Array& arrayValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == ARRAY) ) // type cannot change in mImpl so array is allocated
+ if(mImpl && (mImpl->type == ARRAY)) // type cannot change in mImpl so array is allocated
{
arrayValue = *(mImpl->arrayValue);
- converted = true;
+ converted = true;
}
return converted;
}
-bool Property::Value::Get( Property::Map& mapValue ) const
+bool Property::Value::Get(Property::Map& mapValue) const
{
bool converted = false;
- if( mImpl && (mImpl->type == MAP) ) // type cannot change in mImpl so map is allocated
+ if(mImpl && (mImpl->type == MAP)) // type cannot change in mImpl so map is allocated
{
- mapValue = *(mImpl->mapValue);
+ mapValue = *(mImpl->mapValue);
converted = true;
}
return converted;
Property::Array* Property::Value::GetArray() const
{
Property::Array* array = nullptr;
- if( mImpl && (mImpl->type == ARRAY) ) // type cannot change in mImpl so array is allocated
+ if(mImpl && (mImpl->type == ARRAY)) // type cannot change in mImpl so array is allocated
{
array = mImpl->arrayValue;
}
Property::Map* Property::Value::GetMap() const
{
Property::Map* map = nullptr;
- if( mImpl && (mImpl->type == MAP) ) // type cannot change in mImpl so map is allocated
+ if(mImpl && (mImpl->type == MAP)) // type cannot change in mImpl so map is allocated
{
map = mImpl->mapValue;
}
return map;
}
-bool Property::Value::Get( Extents& extentsValue ) const
+bool Property::Value::Get(Extents& extentsValue) const
{
bool converted = false;
- if( mImpl )
+ if(mImpl)
{
- if( mImpl->type == EXTENTS )
+ if(mImpl->type == EXTENTS)
{
extentsValue = *(mImpl->extentsValue);
- converted = true;
+ converted = true;
}
- else if( mImpl->type == VECTOR4 )
+ else if(mImpl->type == VECTOR4)
{
- extentsValue.start = static_cast< uint16_t >( mImpl->vector4Value->x );
- extentsValue.end = static_cast< uint16_t >( mImpl->vector4Value->y );
- extentsValue.top = static_cast< uint16_t >( mImpl->vector4Value->z );
- extentsValue.bottom = static_cast< uint16_t >( mImpl->vector4Value->w );
- converted = true;
+ extentsValue.start = static_cast<uint16_t>(mImpl->vector4Value->x);
+ extentsValue.end = static_cast<uint16_t>(mImpl->vector4Value->y);
+ extentsValue.top = static_cast<uint16_t>(mImpl->vector4Value->z);
+ extentsValue.bottom = static_cast<uint16_t>(mImpl->vector4Value->w);
+ converted = true;
}
}
return converted;
}
-std::ostream& operator<<( std::ostream& stream, const Property::Value& value )
+std::ostream& operator<<(std::ostream& stream, const Property::Value& value)
{
- if( value.mImpl )
+ if(value.mImpl)
{
- const Property::Value::Impl& impl( *value.mImpl );
+ const Property::Value::Impl& impl(*value.mImpl);
- switch( impl.type )
+ switch(impl.type)
{
case Dali::Property::BOOLEAN:
{
}
case Dali::Property::INTEGER:
{
- stream << impl.integerValue;
- break;
+ stream << impl.integerValue;
+ break;
}
case Dali::Property::VECTOR2:
{
return stream;
}
-
} // namespace Dali
*/
// EXTERNAL INCLUDES
+#include <initializer_list>
#include <iosfwd>
#include <type_traits>
#include <utility>
-#include <initializer_list>
// INTERNAL INCLUDES
-#include <dali/public-api/object/property.h>
#include <dali/public-api/math/rect.h>
-
+#include <dali/public-api/object/property.h>
namespace Dali
{
class Matrix;
struct Extents;
-typedef std::pair< Property::Key, Property::Value > KeyValuePair;
+using KeyValuePair = std::pair<Property::Key, Property::Value>;
/**
* @brief A value-type representing a property value.
class DALI_CORE_API Property::Value
{
public:
-
/**
* @brief Default constructor.
*
* @SINCE_1_0.0
* @param[in] boolValue A boolean value
*/
- Value( bool boolValue );
+ Value(bool boolValue);
/**
* @brief Creates an integer property value.
* @SINCE_1_0.0
* @param[in] integerValue An integer value
*/
- Value( int32_t integerValue );
+ Value(int32_t integerValue);
/**
* @brief Creates a float property value.
* @SINCE_1_0.0
* @param[in] floatValue A floating-point value
*/
- Value( float floatValue );
+ Value(float floatValue);
/**
* @brief Creates a Vector2 property value.
* @SINCE_1_0.0
* @param[in] vectorValue A vector of 2 floating-point values
*/
- Value( const Vector2& vectorValue );
+ Value(const Vector2& vectorValue);
/**
* @brief Creates a Vector3 property value.
* @SINCE_1_0.0
* @param[in] vectorValue A vector of 3 floating-point values
*/
- Value( const Vector3& vectorValue );
+ Value(const Vector3& vectorValue);
/**
* @brief Creates a Vector4 property value.
* @SINCE_1_0.0
* @param[in] vectorValue A vector of 4 floating-point values
*/
- Value( const Vector4& vectorValue );
+ Value(const Vector4& vectorValue);
/**
* @brief Creates a Matrix3 property value.
* @SINCE_1_0.0
* @param[in] matrixValue A matrix of 3x3 floating-point values
*/
- Value( const Matrix3& matrixValue );
+ Value(const Matrix3& matrixValue);
/**
* @brief Creates a Matrix property value.
* @SINCE_1_0.0
* @param[in] matrixValue A matrix of 4x4 floating-point values
*/
- Value( const Matrix& matrixValue );
+ Value(const Matrix& matrixValue);
/**
* @brief Creates a Vector4 property value.
* @SINCE_1_0.0
* @param[in] vectorValue A vector of 4 integer values
*/
- Value( const Rect<int32_t>& vectorValue );
+ Value(const Rect<int32_t>& vectorValue);
/**
* @brief Creates a Vector4 property value.
* @SINCE_1_9.14
* @param[in] vectorValue A vector of 4 float values
*/
- Value( const Rect<float>& vectorValue );
+ Value(const Rect<float>& vectorValue);
/**
* @brief Creates an orientation property value.
* @SINCE_1_0.0
* @param[in] angleAxis An angle-axis representing the rotation
*/
- Value( const AngleAxis& angleAxis );
+ Value(const AngleAxis& angleAxis);
/**
* @brief Creates an orientation property value.
* @SINCE_1_0.0
* @param[in] quaternion A quaternion representing the rotation
*/
- Value( const Quaternion& quaternion );
+ Value(const Quaternion& quaternion);
/**
* @brief Creates an string property value.
* @SINCE_1_0.0
* @param[in] stringValue A string
*/
- Value( const std::string& stringValue );
+ Value(const std::string& stringValue);
/**
* @brief Creates a string property value.
* @SINCE_1_0.0
* @param[in] stringValue A string
*/
- Value( const char* stringValue );
+ Value(const char* stringValue);
/**
* @brief Creates an array property value.
* @SINCE_1_0.0
* @param[in] arrayValue An array
*/
- Value( Property::Array& arrayValue );
+ Value(Property::Array& arrayValue);
/**
* @brief Creates an array property value.
* @SINCE_1_4.16
* @param[in] arrayValue An r-value array
*/
- Value( Property::Array&& arrayValue );
+ Value(Property::Array&& arrayValue);
/**
* @brief Creates a map property value.
* @SINCE_1_0.0
* @param[in] mapValue A map
*/
- Value( Property::Map& mapValue );
+ Value(Property::Map& mapValue);
/**
* @brief Creates a map property value.
* @SINCE_1_4.16
* @param[in] mapValue An r-value map
*/
- Value( Property::Map&& mapValue );
+ Value(Property::Map&& mapValue);
/**
* @brief Create a map property value from an initializer_list.
* @SINCE_1_4.16
* @param [in] values An initializer_list of pairs of index and value.
*/
- Value( const std::initializer_list< KeyValuePair >& values );
+ Value(const std::initializer_list<KeyValuePair>& values);
/**
* @brief Creates an extents property value.
* @SINCE_1_2.62
* @param[in] extentsValue A collection of 4 uint16_t values
*/
- Value( const Extents& extentsValue );
+ Value(const Extents& extentsValue);
/**
* @brief Creates an enumeration property value.
* @SINCE_1_4.36
* @param[in] enumValue An enumeration value
*/
- template< typename T, typename std::enable_if< std::is_enum< T >::value >::type* = nullptr >
- Value( T enumValue ) : Value( static_cast< int32_t >( enumValue ) )
+ template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+ Value(T enumValue)
+ : Value(static_cast<int32_t>(enumValue))
{
}
* @SINCE_1_0.0
* @param[in] type The property value type
*/
- explicit Value( Type type );
+ explicit Value(Type type);
/**
* @brief Copy constructor.
* @SINCE_1_0.0
* @param[in] value The property value to copy
*/
- Value( const Value& value );
+ Value(const Value& value);
/**
* @brief Move constructor.
* @SINCE_1_4.16
* @param[in] value The property value to move from
*/
- Value( Value&& value );
+ Value(Value&& value);
/**
* @brief Assigns a property value.
* @param[in] value The property value to assign from
* @return a reference to this
*/
- Value& operator=( const Value& value );
+ Value& operator=(const Value& value);
/**
* @brief Move assignment operator.
* @param[in] value The property value to move from
* @return a reference to this
*/
- Value& operator=( Value&& value );
+ Value& operator=(Value&& value);
/**
* @brief Non-virtual destructor.
* @SINCE_1_4.36
* @return A value of type T
*/
- template< typename T, typename std::enable_if< ! std::is_enum< T >::value >::type* = nullptr >
+ template<typename T, typename std::enable_if<!std::is_enum<T>::value>::type* = nullptr>
T DALI_INTERNAL Get() const
{
T temp = T(); // value (zero) initialize
- Get( temp );
+ Get(temp);
return temp;
}
* @SINCE_1_4.36
* @return A value of type T
*/
- template< typename T, typename std::enable_if< std::is_enum< T >::value >::type* = nullptr >
+ template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
T DALI_INTERNAL Get() const
{
int32_t temp = 0; // value (zero) initialize
- Get( temp );
- return static_cast< T >( temp );
+ Get(temp);
+ return static_cast<T>(temp);
}
/**
* @return @c true if the value is successfully retrieved, @c false if the type is different
* @pre GetType() is any enumeration
*/
- template< typename T, typename std::enable_if< std::is_enum< T >::value >::type* = nullptr >
- bool DALI_INTERNAL Get( T& enumValue ) const
+ template<typename T, typename std::enable_if<std::is_enum<T>::value>::type* = nullptr>
+ bool DALI_INTERNAL Get(T& enumValue) const
{
int32_t temp = 0;
- if( ! Get( temp ) )
+ if(!Get(temp))
{
return false;
}
- enumValue = static_cast< T >( temp );
+ enumValue = static_cast<T>(temp);
return true;
}
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to bool.
*/
- bool Get( bool& boolValue ) const;
+ bool Get(bool& boolValue) const;
/**
* @brief Retrieves a floating-point value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to float.
*/
- bool Get( float& floatValue ) const;
+ bool Get(float& floatValue) const;
/**
* @brief Retrieves an integer value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to int.
*/
- bool Get( int32_t& integerValue ) const;
+ bool Get(int32_t& integerValue) const;
/**
* @brief Retrieves an integer rectangle.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Rect<int>.
*/
- bool Get( Rect<int32_t>& rect ) const;
+ bool Get(Rect<int32_t>& rect) const;
/**
* @brief Retrieves a vector value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Vector2.
*/
- bool Get( Vector2& vectorValue ) const;
+ bool Get(Vector2& vectorValue) const;
/**
* @brief Retrieves a vector value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Vector3.
*/
- bool Get( Vector3& vectorValue ) const;
+ bool Get(Vector3& vectorValue) const;
/**
* @brief Retrieves a vector value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Vector4.
*/
- bool Get( Vector4& vectorValue ) const;
+ bool Get(Vector4& vectorValue) const;
/**
* @brief Retrieves a matrix3 value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Matrix3.
*/
- bool Get( Matrix3& matrixValue ) const;
+ bool Get(Matrix3& matrixValue) const;
/**
* @brief Retrieves a matrix value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Matrix.
*/
- bool Get( Matrix& matrixValue ) const;
+ bool Get(Matrix& matrixValue) const;
/**
* @brief Retrieves an angle-axis value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to AngleAxis.
*/
- bool Get( AngleAxis& angleAxisValue ) const;
+ bool Get(AngleAxis& angleAxisValue) const;
/**
* @brief Retrieves a quaternion value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Quaternion.
*/
- bool Get( Quaternion& quaternionValue ) const;
+ bool Get(Quaternion& quaternionValue) const;
/**
* @brief Retrieves an string property value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to string.
*/
- bool Get( std::string& stringValue ) const;
+ bool Get(std::string& stringValue) const;
/**
* @brief Retrieves an array property value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() returns Property::ARRAY.
*/
- bool Get( Property::Array& arrayValue ) const;
+ bool Get(Property::Array& arrayValue) const;
/**
* @brief Retrieves an map property value.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() returns Property::MAP.
*/
- bool Get( Property::Map& mapValue ) const;
+ bool Get(Property::Map& mapValue) const;
/**
* @brief Retrieves the Array API of the Property::Value without copying the contents of the map.
* @return @c true if the value is successfully retrieved, @c false if the type is not convertible
* @pre GetType() is a type convertible to Extents.
*/
- bool Get( Extents& extentsValue ) const;
+ bool Get(Extents& extentsValue) const;
/**
* @brief Output to stream.
* @SINCE_1_0.0
*/
- friend DALI_CORE_API std::ostream& operator<<( std::ostream& ouputStream, const Property::Value& value );
+ friend DALI_CORE_API std::ostream& operator<<(std::ostream& ouputStream, const Property::Value& value);
private:
-
struct DALI_INTERNAL Impl;
- Impl* mImpl; ///< Pointer to the implementation
-
+ Impl* mImpl; ///< Pointer to the implementation
};
/**
* @param[in] value The value to insert
* @return The output stream operator
*/
-DALI_CORE_API std::ostream& operator<<( std::ostream& ouputStream, const Property::Value& value );
+DALI_CORE_API std::ostream& operator<<(std::ostream& ouputStream, const Property::Value& value);
/**
* @}
namespace Dali
{
-
Property::Property(Handle& obj, Property::Index propIndex)
: object(obj),
propertyIndex(propIndex),
propertyIndex(Property::INVALID_INDEX),
componentIndex(Property::INVALID_COMPONENT_INDEX)
{
- propertyIndex = object.GetPropertyIndex( propertyName );
+ propertyIndex = object.GetPropertyIndex(propertyName);
}
Property::Property(Handle& obj, const std::string& propertyName, int32_t compIndex)
propertyIndex(Property::INVALID_INDEX),
componentIndex(compIndex)
{
- propertyIndex = object.GetPropertyIndex( propertyName );
+ propertyIndex = object.GetPropertyIndex(propertyName);
}
Property::~Property()
*/
// EXTERNAL INCLUDES
+#include <cstdint> // int32_t
#include <string>
#include <utility>
-#include <cstdint> // int32_t
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
* @brief A valid property index is zero or greater.
* @SINCE_1_0.0
*/
- typedef int32_t Index;
+ using Index = int32_t;
- static constexpr int32_t INVALID_INDEX{-1}; ///< -1 is not a valid property index
- static constexpr int32_t INVALID_KEY{-1}; ///< -1 is not a valid property key
+ static constexpr int32_t INVALID_INDEX{-1}; ///< -1 is not a valid property index
+ static constexpr int32_t INVALID_KEY{-1}; ///< -1 is not a valid property key
static constexpr int32_t INVALID_COMPONENT_INDEX{-1}; ///< -1 is not a valid property index
- typedef Dali::Vector< Index > IndexContainer; ///< A vector of property indices @SINCE_1_0.0
+ using IndexContainer = Dali::Vector<Index>; ///< A vector of property indices @SINCE_1_0.0
/**
* @brief A value-type representing a property value.
*/
enum Type
{
- NONE, ///< No type @SINCE_1_0.0
-
- BOOLEAN, ///< A boolean type @SINCE_1_0.0
- FLOAT, ///< A float type @SINCE_1_0.0
- INTEGER, ///< An integer type @SINCE_1_0.0
- VECTOR2, ///< a vector array of size=2 with float precision @SINCE_1_0.0
- VECTOR3, ///< a vector array of size=3 with float precision @SINCE_1_0.0
- VECTOR4, ///< a vector array of size=4 with float precision @SINCE_1_0.0
- MATRIX3, ///< a 3x3 matrix @SINCE_1_0.0
- MATRIX, ///< a 4x4 matrix @SINCE_1_0.0
- RECTANGLE, ///< an integer array of size=4 @SINCE_1_0.0
- ROTATION, ///< either a quaternion or an axis angle rotation @SINCE_1_0.0
- STRING, ///< A string type @SINCE_1_0.0
- ARRAY, ///< an array of Property::Value @SINCE_1_0.0
- MAP, ///< a string key to Property:value mapping @SINCE_1_0.0
- EXTENTS ///< a collection of 4 x uint16_t @SINCE_1_2.62
+ NONE, ///< No type @SINCE_1_0.0
+
+ BOOLEAN, ///< A boolean type @SINCE_1_0.0
+ FLOAT, ///< A float type @SINCE_1_0.0
+ INTEGER, ///< An integer type @SINCE_1_0.0
+ VECTOR2, ///< a vector array of size=2 with float precision @SINCE_1_0.0
+ VECTOR3, ///< a vector array of size=3 with float precision @SINCE_1_0.0
+ VECTOR4, ///< a vector array of size=4 with float precision @SINCE_1_0.0
+ MATRIX3, ///< a 3x3 matrix @SINCE_1_0.0
+ MATRIX, ///< a 4x4 matrix @SINCE_1_0.0
+ RECTANGLE, ///< an integer array of size=4 @SINCE_1_0.0
+ ROTATION, ///< either a quaternion or an axis angle rotation @SINCE_1_0.0
+ STRING, ///< A string type @SINCE_1_0.0
+ ARRAY, ///< an array of Property::Value @SINCE_1_0.0
+ MAP, ///< a string key to Property:value mapping @SINCE_1_0.0
+ EXTENTS ///< a collection of 4 x uint16_t @SINCE_1_2.62
};
/**
*/
enum AccessMode
{
- READ_ONLY, ///< if the property is read-only @SINCE_1_0.0
- READ_WRITE, ///< If the property is read/writeable @SINCE_1_0.0
- ANIMATABLE, ///< If the property can be animated or constrained @SINCE_1_0.0
- ACCESS_MODE_COUNT ///< The number of access modes @SINCE_1_0.0
+ READ_ONLY, ///< if the property is read-only @SINCE_1_0.0
+ READ_WRITE, ///< If the property is read/writeable @SINCE_1_0.0
+ ANIMATABLE, ///< If the property can be animated or constrained @SINCE_1_0.0
+ ACCESS_MODE_COUNT ///< The number of access modes @SINCE_1_0.0
};
-
/**
* @brief Creates a Property instance.
*
* @param[in] object A valid handle to the target object
* @param[in] propertyIndex The index of a property
*/
- Property( Handle& object, Property::Index propertyIndex );
-
+ Property(Handle& object, Property::Index propertyIndex);
/**
* @brief Creates a Property instance.
* @param[in] propertyIndex The index of a property.
* @param[in] componentIndex Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for main property (default is -1)
*/
- Property( Handle& object, Property::Index propertyIndex, int32_t componentIndex );
+ Property(Handle& object, Property::Index propertyIndex, int32_t componentIndex);
/**
* @brief Creates a Property instance.
* @note This performs a property index query and is therefore slower than
* constructing a Property directly with the index.
*/
- Property( Handle& object, const std::string& propertyName );
+ Property(Handle& object, const std::string& propertyName);
/**
* @brief Creates a Property instance.
* @note This performs a property index query and is therefore slower than
* constructing a Property directly with the index.
*/
- Property( Handle& object, const std::string& propertyName, int32_t componentIndex );
+ Property(Handle& object, const std::string& propertyName, int32_t componentIndex);
/**
* @brief Non-virtual destructor; Property is not intended as a base class.
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
void RefObject::Reference()
{
+ // clang-format off
// The inline assembly below was tested on an ARMv8 64 bit platform on
// 2015-02-06 and found to run in 11.8 nanoseconds, whereas
// __sync_add_and_fetch( address, 1 ) required 18.8 nanoseconds.
__sync_add_and_fetch( &mCount, 1 );
#endif
+ // clang-format on
}
void RefObject::Unreference()
{
+ // clang-format off
+
// The output register:
int32_t newValue;
{
delete this;
}
+ // clang-format on
}
uint32_t RefObject::ReferenceCount()
}
} // namespace Dali
-
-
#define DALI_REF_OBJECT_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 DALI_CORE_API RefObject
{
public:
-
/**
* @brief Increments the object's reference count.
* @SINCE_1_0.0
uint32_t ReferenceCount();
protected:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
RefObject& operator=(const RefObject& rhs);
private:
-
volatile uint32_t mCount; ///< Reference count
};
namespace Dali
{
-
TypeInfo::TypeInfo()
{
}
TypeInfo& TypeInfo::operator=(const TypeInfo& rhs) = default;
-TypeInfo::TypeInfo( TypeInfo&& rhs ) = default;
+TypeInfo::TypeInfo(TypeInfo&& rhs) = default;
-TypeInfo& TypeInfo::operator=( TypeInfo&& rhs ) = default;
+TypeInfo& TypeInfo::operator=(TypeInfo&& rhs) = default;
const std::string& TypeInfo::GetName() const
{
std::string TypeInfo::GetActionName(size_t index)
{
- return GetImplementation(*this).GetActionName( static_cast<uint32_t>( index ) );
+ return GetImplementation(*this).GetActionName(static_cast<uint32_t>(index));
}
size_t TypeInfo::GetSignalCount() const
std::string TypeInfo::GetSignalName(size_t index)
{
- return GetImplementation(*this).GetSignalName( static_cast<uint32_t>( index ) );
+ return GetImplementation(*this).GetSignalName(static_cast<uint32_t>(index));
}
size_t TypeInfo::GetPropertyCount() const
return GetImplementation(*this).GetPropertyCount();
}
-void TypeInfo::GetPropertyIndices( Property::IndexContainer& indices ) const
+void TypeInfo::GetPropertyIndices(Property::IndexContainer& indices) const
{
indices.Clear(); // We do not want to clear the container if called internally, so only clear here
- GetImplementation(*this).GetPropertyIndices( indices );
+ GetImplementation(*this).GetPropertyIndices(indices);
}
-const std::string& TypeInfo::GetPropertyName( Property::Index index ) const
+const std::string& TypeInfo::GetPropertyName(Property::Index index) const
{
- return GetImplementation(*this).GetRegisteredPropertyName( index );
+ return GetImplementation(*this).GetRegisteredPropertyName(index);
}
-Property::Index TypeInfo::GetChildPropertyIndex( const std::string& name ) const
+Property::Index TypeInfo::GetChildPropertyIndex(const std::string& name) const
{
- return GetImplementation(*this).GetChildPropertyIndex( name );
+ return GetImplementation(*this).GetChildPropertyIndex(name);
}
-const std::string& TypeInfo::GetChildPropertyName( Property::Index index ) const
+const std::string& TypeInfo::GetChildPropertyName(Property::Index index) const
{
- return GetImplementation(*this).GetChildPropertyName( index );
+ return GetImplementation(*this).GetChildPropertyName(index);
}
-Property::Type TypeInfo::GetChildPropertyType( Property::Index index ) const
+Property::Type TypeInfo::GetChildPropertyType(Property::Index index) const
{
- return GetImplementation(*this).GetChildPropertyType( index );
+ return GetImplementation(*this).GetChildPropertyType(index);
}
-void TypeInfo::GetChildPropertyIndices( Property::IndexContainer& indices ) const
+void TypeInfo::GetChildPropertyIndices(Property::IndexContainer& indices) const
{
indices.Clear(); // We do not want to clear the container if called internally, so only clear here
- GetImplementation(*this).GetChildPropertyIndices( indices );
+ GetImplementation(*this).GetChildPropertyIndices(indices);
}
TypeInfo::TypeInfo(Internal::TypeInfo* internal)
#include <cstdint> // uint32_t
// INTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/common/vector-wrapper.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
namespace Internal DALI_INTERNAL
{
- class TypeInfo;
+class TypeInfo;
};
/**
class DALI_CORE_API TypeInfo : public BaseHandle
{
public:
-
using CreateFunction = BaseHandle (*)(); ///< Function signature for creating an instance of the associated object type. @SINCE_1_0.0
using ActionFunction = bool (*)(BaseObject*, const std::string&, const Property::Map&); ///< Function signature for creating scriptable actions @SINCE_1_0.0
* @param[in] value The new value of the property for the object specified
* @see PropertyRegistration.
*/
- using SetPropertyFunction = void (*)( BaseObject* object, Property::Index index, const Property::Value& value );
+ using SetPropertyFunction = void (*)(BaseObject* object, Property::Index index, const Property::Value& value);
/**
* @brief Callback to get the value of an event-thread only property.
* @return The current value of the property for the object specified
* @see PropertyRegistration.
*/
- using GetPropertyFunction = Property::Value (*)( BaseObject* object, Property::Index index );
+ using GetPropertyFunction = Property::Value (*)(BaseObject* object, Property::Index index);
/**
* @brief Allows the creation of an empty TypeInfo handle.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- TypeInfo( TypeInfo&& rhs );
+ TypeInfo(TypeInfo&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TypeInfo& operator=( TypeInfo&& rhs );
+ TypeInfo& operator=(TypeInfo&& rhs);
/**
* @brief Retrieves the type name for this type.
* @param[out] indices Container of property indices
* @note The container will be cleared
*/
- void GetPropertyIndices( Property::IndexContainer& indices ) const;
+ void GetPropertyIndices(Property::IndexContainer& indices) const;
/**
* @brief Retrieves all the child property indices for this type.
* @param[out] indices Container of property indices
* @note The container will be cleared
*/
- void GetChildPropertyIndices( Property::IndexContainer& indices ) const;
+ void GetChildPropertyIndices(Property::IndexContainer& indices) const;
/**
* @brief Given a property index, retrieve the property name associated with it.
* @exception DaliException If index is not valid.
* @note this method only works for custom registered properties
*/
- const std::string& GetPropertyName( Property::Index index ) const;
-
+ const std::string& GetPropertyName(Property::Index index) const;
/**
* @brief Given a child property name, retrieve the property index associated with it,
* @param[in] name The name of the property at the given index,
* @return The property index or Property::INVALID_INDEX
*/
- Property::Index GetChildPropertyIndex( const std::string& name ) const;
+ Property::Index GetChildPropertyIndex(const std::string& name) const;
/**
* @brief Given a child property index, retrieve the property name associated with it.
* @param[in] index The property index
* @return The name of the property at the given index, or empty string if it does not exist
*/
- const std::string& GetChildPropertyName( Property::Index index ) const;
+ const std::string& GetChildPropertyName(Property::Index index) const;
/**
* @brief Given a child property index, retrieve the property name associated with it.
* @param[in] index The property index
* @return The name of the property at the given index, or empty string if it does not exist
*/
- Property::Type GetChildPropertyType( Property::Index index ) const;
-
-
+ Property::Type GetChildPropertyType(Property::Index index) const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali Get() method.
*/
explicit DALI_INTERNAL TypeInfo(Internal::TypeInfo* typeInfo);
/// @endcond
-
};
/**
* These internal macros exist as to perform the compile-time check on the enumeration order, the __COUNTER__ macro is used twice.
* Using it twice within the same macro would result in two different values.
*/
-#define DALI_TOKEN_PASTE_EXPAND( x, y ) x ## y
-#define DALI_TOKEN_PASTE( x, y ) DALI_TOKEN_PASTE_EXPAND(x, y)
+#define DALI_TOKEN_PASTE_EXPAND(x, y) x##y
+#define DALI_TOKEN_PASTE(x, y) DALI_TOKEN_PASTE_EXPAND(x, y)
-#define DALI_PROPERTY_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex ) \
- Dali::PropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, Dali::Property::valueType, &objectType::SetProperty, &objectType::GetProperty ); \
- static_assert( ( objectNamespace::objectType::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX ) == count );
+#define DALI_PROPERTY_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex) \
+ Dali::PropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, Dali::Property::valueType, &objectType::SetProperty, &objectType::GetProperty); \
+ static_assert((objectNamespace::objectType::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX) == count);
-#define DALI_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY( count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex ) \
- Dali::PropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, Dali::Property::valueType, NULL, &objectType::GetProperty ); \
- static_assert( ( objectNamespace::objectType::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX ) == count );
+#define DALI_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY(count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex) \
+ Dali::PropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, Dali::Property::valueType, NULL, &objectType::GetProperty); \
+ static_assert((objectNamespace::objectType::Property::enumIndex - objectNamespace::objectType::PROPERTY_START_INDEX) == count);
-#define DALI_ANIMATABLE_PROPERTY_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex) \
- Dali::AnimatablePropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, Dali::Property::valueType );
+#define DALI_ANIMATABLE_PROPERTY_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex) \
+ Dali::AnimatablePropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, Dali::Property::valueType);
-#define DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, value, enumIndex) \
- Dali::AnimatablePropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, value );
+#define DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, value, enumIndex) \
+ Dali::AnimatablePropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, value);
-#define DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex) \
- Dali::AnimatablePropertyComponentRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, objectNamespace::objectType::Property::baseEnumIndex, componentIndex );
+#define DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex) \
+ Dali::AnimatablePropertyComponentRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::objectType::Property::enumIndex, objectNamespace::objectType::Property::baseEnumIndex, componentIndex);
-#define DALI_CHILD_PROPERTY_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex ) \
- Dali::ChildPropertyRegistration DALI_TOKEN_PASTE( property, count ) ( typeRegistrationObject, text, objectNamespace::objectType::ChildProperty::enumIndex, Property::valueType );
+#define DALI_CHILD_PROPERTY_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, valueType, enumIndex) \
+ Dali::ChildPropertyRegistration DALI_TOKEN_PASTE(property, count)(typeRegistrationObject, text, objectNamespace::objectType::ChildProperty::enumIndex, Property::valueType);
-#define DALI_SIGNAL_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, textVariable ) \
- const char* const textVariable = text; \
- Dali::SignalConnectorType DALI_TOKEN_PASTE( signalConnector, count ) ( typeRegistrationObject, text, &objectNamespace::Internal::objectType::DoConnectSignal );
-
-#define DALI_ACTION_REGISTRATION_INTERNAL( count, typeRegistrationObject, objectNamespace, objectType, text, textVariable ) \
- const char* const textVariable = text; \
- Dali::TypeAction DALI_TOKEN_PASTE( signalConnector, count ) ( typeRegistrationObject, text, &objectNamespace::Internal::objectType::DoAction );
+#define DALI_SIGNAL_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, textVariable) \
+ const char* const textVariable = text; \
+ Dali::SignalConnectorType DALI_TOKEN_PASTE(signalConnector, count)(typeRegistrationObject, text, &objectNamespace::Internal::objectType::DoConnectSignal);
+#define DALI_ACTION_REGISTRATION_INTERNAL(count, typeRegistrationObject, objectNamespace, objectType, text, textVariable) \
+ const char* const textVariable = text; \
+ Dali::TypeAction DALI_TOKEN_PASTE(signalConnector, count)(typeRegistrationObject, text, &objectNamespace::Internal::objectType::DoAction);
/**
* @brief These macros are used to define properties for implementations of CustomActor.
* Using these macros have certain prerequisites on how the property enumeration is defined.
* Please see the Programming Guide (within the generated Doxygen) for full details.
*/
-#define DALI_TYPE_REGISTRATION_BEGIN( thisType, baseType, createFunction ) \
- Dali::TypeRegistration typeRegistration( typeid( thisType ), typeid( baseType ), createFunction );
-
-#define DALI_TYPE_REGISTRATION_BEGIN_CREATE( thisType, baseType, createFunction, createAtStartup ) \
- Dali::TypeRegistration typeRegistration( typeid( thisType ), typeid( baseType ), createFunction, createAtStartup );
+#define DALI_TYPE_REGISTRATION_BEGIN(thisType, baseType, createFunction) \
+ Dali::TypeRegistration typeRegistration(typeid(thisType), typeid(baseType), createFunction);
-#define DALI_PROPERTY_REGISTRATION( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_PROPERTY_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex )
+#define DALI_TYPE_REGISTRATION_BEGIN_CREATE(thisType, baseType, createFunction, createAtStartup) \
+ Dali::TypeRegistration typeRegistration(typeid(thisType), typeid(baseType), createFunction, createAtStartup);
-#define DALI_PROPERTY_REGISTRATION_READ_ONLY( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY( __COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex )
+#define DALI_PROPERTY_REGISTRATION(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_PROPERTY_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex)
-#define DALI_ANIMATABLE_PROPERTY_REGISTRATION( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_ANIMATABLE_PROPERTY_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex )
+#define DALI_PROPERTY_REGISTRATION_READ_ONLY(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_PROPERTY_REGISTRATION_INTERNAL_READ_ONLY(__COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex)
-#define DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT( objectNamespace, objectType, text, value, enumIndex ) \
- DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, value, enumIndex )
+#define DALI_ANIMATABLE_PROPERTY_REGISTRATION(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_ANIMATABLE_PROPERTY_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex)
-#define DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION( objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex ) \
- DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex )
+#define DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT(objectNamespace, objectType, text, value, enumIndex) \
+ DALI_ANIMATABLE_PROPERTY_REGISTRATION_WITH_DEFAULT_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, value, enumIndex)
-#define DALI_CHILD_PROPERTY_REGISTRATION( objectNamespace, objectType, text, valueType, enumIndex ) \
- DALI_CHILD_PROPERTY_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex )
+#define DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION(objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex) \
+ DALI_ANIMATABLE_PROPERTY_COMPONENT_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, enumIndex, baseEnumIndex, componentIndex)
-#define DALI_SIGNAL_REGISTRATION( objectNamespace, objectType, text, textVariable ) \
- DALI_SIGNAL_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, textVariable )
+#define DALI_CHILD_PROPERTY_REGISTRATION(objectNamespace, objectType, text, valueType, enumIndex) \
+ DALI_CHILD_PROPERTY_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, valueType, enumIndex)
-#define DALI_ACTION_REGISTRATION( objectNamespace, objectType, text, textVariable ) \
- DALI_ACTION_REGISTRATION_INTERNAL( __COUNTER__, typeRegistration, objectNamespace, objectType, text, textVariable )
+#define DALI_SIGNAL_REGISTRATION(objectNamespace, objectType, text, textVariable) \
+ DALI_SIGNAL_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, textVariable)
-#define DALI_TYPE_REGISTRATION_END( ) // This macro exists for consistency and readability.
+#define DALI_ACTION_REGISTRATION(objectNamespace, objectType, text, textVariable) \
+ DALI_ACTION_REGISTRATION_INTERNAL(__COUNTER__, typeRegistration, objectNamespace, objectType, text, textVariable)
+#define DALI_TYPE_REGISTRATION_END() // This macro exists for consistency and readability.
#endif // DALI_TYPE_REGISTRY_HELPER_H
// EXTERNAL INCLUDES
// INTERNAL INCLUDES
-#include <dali/public-api/object/property-index-ranges.h>
#include <dali/internal/event/common/type-registry-impl.h>
#include <dali/internal/event/object/default-property-metadata.h>
+#include <dali/public-api/object/property-index-ranges.h>
namespace Dali
{
-
TypeRegistry::TypeRegistry()
{
}
TypeRegistry& TypeRegistry::operator=(const TypeRegistry& rhs) = default;
-TypeRegistry::TypeRegistry( TypeRegistry&& rhs ) = default;
+TypeRegistry::TypeRegistry(TypeRegistry&& rhs) = default;
-TypeRegistry& TypeRegistry::operator=( TypeRegistry&& rhs ) = default;
+TypeRegistry& TypeRegistry::operator=(TypeRegistry&& rhs) = default;
TypeRegistry TypeRegistry::Get()
{
return TypeRegistry(Internal::TypeRegistry::Get());
}
-Dali::TypeInfo TypeRegistry::GetTypeInfo( const std::string &uniqueTypeName )
+Dali::TypeInfo TypeRegistry::GetTypeInfo(const std::string& uniqueTypeName)
{
- return Dali::TypeInfo( GetImplementation(*this).GetTypeInfo( uniqueTypeName ).Get() );
+ return Dali::TypeInfo(GetImplementation(*this).GetTypeInfo(uniqueTypeName).Get());
}
-Dali::TypeInfo TypeRegistry::GetTypeInfo( const std::type_info& registerType )
+Dali::TypeInfo TypeRegistry::GetTypeInfo(const std::type_info& registerType)
{
- return Dali::TypeInfo( GetImplementation(*this).GetTypeInfo( registerType ).Get() );
+ return Dali::TypeInfo(GetImplementation(*this).GetTypeInfo(registerType).Get());
}
size_t TypeRegistry::GetTypeNameCount() const
std::string TypeRegistry::GetTypeName(size_t index) const
{
- return GetImplementation(*this).GetTypeName( static_cast<uint32_t>( index ) );
+ return GetImplementation(*this).GetTypeName(static_cast<uint32_t>(index));
}
TypeRegistry::TypeRegistry(Internal::TypeRegistry* internal)
{
}
-TypeRegistration::TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
- TypeInfo::CreateFunction f )
- : mReference(Internal::TypeRegistry::Get())
+TypeRegistration::TypeRegistration(const std::type_info& registerType, const std::type_info& baseType, TypeInfo::CreateFunction f)
+: mReference(Internal::TypeRegistry::Get())
{
- Internal::TypeRegistry *impl = Internal::TypeRegistry::Get();
+ Internal::TypeRegistry* impl = Internal::TypeRegistry::Get();
- mName = impl->Register( registerType, baseType, f, false );
+ mName = impl->Register(registerType, baseType, f, false);
}
-TypeRegistration::TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
- TypeInfo::CreateFunction f, bool callCreateOnInit )
- : mReference(Internal::TypeRegistry::Get())
+TypeRegistration::TypeRegistration(const std::type_info& registerType, const std::type_info& baseType, TypeInfo::CreateFunction f, bool callCreateOnInit)
+: mReference(Internal::TypeRegistry::Get())
{
- Internal::TypeRegistry *impl = Internal::TypeRegistry::Get();
+ Internal::TypeRegistry* impl = Internal::TypeRegistry::Get();
- mName = impl->Register( registerType, baseType, f, callCreateOnInit );
+ mName = impl->Register(registerType, baseType, f, callCreateOnInit);
}
-TypeRegistration::TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
- TypeInfo::CreateFunction f, const DefaultPropertyMetadata& defaultProperties )
+TypeRegistration::TypeRegistration(const std::type_info& registerType, const std::type_info& baseType, TypeInfo::CreateFunction f, const DefaultPropertyMetadata& defaultProperties)
{
- Internal::TypeRegistry *impl = Internal::TypeRegistry::Get();
+ Internal::TypeRegistry* impl = Internal::TypeRegistry::Get();
- mName = impl->Register( registerType, baseType, f, false, defaultProperties.propertyTable, defaultProperties.propertyCount );
+ mName = impl->Register(registerType, baseType, f, false, defaultProperties.propertyTable, defaultProperties.propertyCount);
}
-TypeRegistration::TypeRegistration( const std::string& name, const std::type_info& baseType,
- TypeInfo::CreateFunction f )
- : mReference(Internal::TypeRegistry::Get())
+TypeRegistration::TypeRegistration(std::string name, const std::type_info& baseType, TypeInfo::CreateFunction f)
+: mReference(Internal::TypeRegistry::Get())
{
- Internal::TypeRegistry *impl = Internal::TypeRegistry::Get();
+ Internal::TypeRegistry* impl = Internal::TypeRegistry::Get();
- mName = impl->Register( name, baseType, f, false );
+ mName = impl->Register(std::move(name), baseType, f, false);
}
-
-const std::string TypeRegistration::RegisteredName() const
+const std::string& TypeRegistration::RegisteredName() const
{
return mName;
}
-SignalConnectorType::SignalConnectorType( TypeRegistration& typeRegistration, const std::string& name, TypeInfo::SignalConnectorFunction func )
+SignalConnectorType::SignalConnectorType(TypeRegistration& typeRegistration, std::string name, TypeInfo::SignalConnectorFunction func)
{
- Internal::TypeRegistry::Get()->RegisterSignal( typeRegistration, name, func );
+ Internal::TypeRegistry::Get()->RegisterSignal(typeRegistration, std::move(name), func);
}
-TypeAction::TypeAction( TypeRegistration ®istered, const std::string &name, TypeInfo::ActionFunction f)
+TypeAction::TypeAction(TypeRegistration& registered, std::string name, TypeInfo::ActionFunction f)
{
- Internal::TypeRegistry::Get()->RegisterAction( registered, name, f );
+ Internal::TypeRegistry::Get()->RegisterAction(registered, std::move(name), f);
}
-PropertyRegistration::PropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type, TypeInfo::SetPropertyFunction setFunc, TypeInfo::GetPropertyFunction getFunc )
+PropertyRegistration::PropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type, TypeInfo::SetPropertyFunction setFunc, TypeInfo::GetPropertyFunction getFunc)
{
- DALI_ASSERT_ALWAYS( ( index >= PROPERTY_REGISTRATION_START_INDEX ) && ( index <= PROPERTY_REGISTRATION_MAX_INDEX ) );
+ DALI_ASSERT_ALWAYS((index >= PROPERTY_REGISTRATION_START_INDEX) && (index <= PROPERTY_REGISTRATION_MAX_INDEX));
- Internal::TypeRegistry::Get()->RegisterProperty( registered, name, index, type, setFunc, getFunc );
+ Internal::TypeRegistry::Get()->RegisterProperty(registered, std::move(name), index, type, setFunc, getFunc);
}
-AnimatablePropertyRegistration::AnimatablePropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type )
+AnimatablePropertyRegistration::AnimatablePropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type)
{
- DALI_ASSERT_ALWAYS( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) );
+ DALI_ASSERT_ALWAYS((index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX));
- Internal::TypeRegistry::Get()->RegisterAnimatableProperty( registered, name, index, type );
+ Internal::TypeRegistry::Get()->RegisterAnimatableProperty(registered, std::move(name), index, type);
}
-AnimatablePropertyRegistration::AnimatablePropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, const Property::Value& value )
+AnimatablePropertyRegistration::AnimatablePropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, const Property::Value& value)
{
- DALI_ASSERT_ALWAYS( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) );
+ DALI_ASSERT_ALWAYS((index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX));
- Internal::TypeRegistry::Get()->RegisterAnimatableProperty( registered, name, index, value );
+ Internal::TypeRegistry::Get()->RegisterAnimatableProperty(registered, std::move(name), index, value);
}
-AnimatablePropertyComponentRegistration::AnimatablePropertyComponentRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex)
+AnimatablePropertyComponentRegistration::AnimatablePropertyComponentRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex)
{
- DALI_ASSERT_ALWAYS( ( index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX ) );
+ DALI_ASSERT_ALWAYS((index >= ANIMATABLE_PROPERTY_REGISTRATION_START_INDEX) && (index <= ANIMATABLE_PROPERTY_REGISTRATION_MAX_INDEX));
- Internal::TypeRegistry::Get()->RegisterAnimatablePropertyComponent( registered, name, index, baseIndex, componentIndex );
+ Internal::TypeRegistry::Get()->RegisterAnimatablePropertyComponent(registered, std::move(name), index, baseIndex, componentIndex);
}
-ChildPropertyRegistration::ChildPropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type )
+ChildPropertyRegistration::ChildPropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type)
{
- DALI_ASSERT_ALWAYS( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX ) );
+ DALI_ASSERT_ALWAYS((index >= CHILD_PROPERTY_REGISTRATION_START_INDEX) && (index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX));
- Internal::TypeRegistry::Get()->RegisterChildProperty( registered, name, index, type );
+ Internal::TypeRegistry::Get()->RegisterChildProperty(registered, std::move(name), index, type);
}
-ChildPropertyRegistration::ChildPropertyRegistration( const std::string& registered, const std::string& name, Property::Index index, Property::Type type )
+ChildPropertyRegistration::ChildPropertyRegistration(std::string registered, std::string name, Property::Index index, Property::Type type)
{
- DALI_ASSERT_ALWAYS( ( index >= CHILD_PROPERTY_REGISTRATION_START_INDEX ) && ( index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX ) );
+ DALI_ASSERT_ALWAYS((index >= CHILD_PROPERTY_REGISTRATION_START_INDEX) && (index <= CHILD_PROPERTY_REGISTRATION_MAX_INDEX));
- Internal::TypeRegistry::Get()->RegisterChildProperty( registered, name, index, type );
+ Internal::TypeRegistry::Get()->RegisterChildProperty(std::move(registered), std::move(name), index, type);
}
-
} // namespace Dali
*/
// EXTERNAL INCLUDES
-#include <typeinfo>
#include <cstdint> // uint32_t
+#include <typeinfo>
// INTERNAL INCLUDES
#include <dali/public-api/object/base-handle.h>
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- TypeRegistry( TypeRegistry&& rhs );
+ TypeRegistry(TypeRegistry&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TypeRegistry& operator=( TypeRegistry&& rhs );
+ TypeRegistry& operator=(TypeRegistry&& rhs);
/**
* @brief Gets TypeInfo for a registered type.
* @param[in] uniqueTypeName A unique type name
* @return TypeInfo if the type exists, otherwise an empty handle
*/
- TypeInfo GetTypeInfo( const std::string &uniqueTypeName );
+ TypeInfo GetTypeInfo(const std::string& uniqueTypeName);
/**
* @brief Gets TypeInfo for a registered type.
* @param[in] registerType The registered type info
* @return TypeInfo if the type exists, otherwise an empty handle
*/
- TypeInfo GetTypeInfo( const std::type_info& registerType );
+ TypeInfo GetTypeInfo(const std::type_info& registerType);
/**
* @brief Gets type name count.
std::string GetTypeName(size_t index) const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali Get() method.
* @SINCE_1_0.0
* @param[in] typeRegistry A pointer to a Dali resource
*/
- explicit DALI_INTERNAL TypeRegistry(Internal::TypeRegistry*typeRegistry);
+ explicit DALI_INTERNAL TypeRegistry(Internal::TypeRegistry* typeRegistry);
/// @endcond
};
* @param[in] baseType The base type info of registerType
* @param[in] f registerType Instance creation function
*/
- TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
- TypeInfo::CreateFunction f );
+ TypeRegistration(const std::type_info& registerType, const std::type_info& baseType, TypeInfo::CreateFunction f);
/**
* @brief Constructor registers the type creation function.
* @param[in] f registerType instance creation function
* @param[in] callCreateOnInit If true the creation function is called as part of Dali initialization
*/
- TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
- TypeInfo::CreateFunction f, bool callCreateOnInit );
+ TypeRegistration(const std::type_info& registerType, const std::type_info& baseType, TypeInfo::CreateFunction f, bool callCreateOnInit);
/**
* @brief Constructor registers the type creation function.
* @param[in] f registerType instance creation function
* @param[in] defaultProperties the default property meta-data
*/
- TypeRegistration( const std::type_info& registerType, const std::type_info& baseType,
- TypeInfo::CreateFunction f, const DefaultPropertyMetadata& defaultProperties );
+ TypeRegistration(const std::type_info& registerType, const std::type_info& baseType, TypeInfo::CreateFunction f, const DefaultPropertyMetadata& defaultProperties);
/**
* @brief Constructor registers the type creation function for a named class or type.
* @param[in] baseType the base type info of registerType
* @param[in] f registerType instance creation function
*/
- TypeRegistration( const std::string& name, const std::type_info& baseType,
- TypeInfo::CreateFunction f );
+ TypeRegistration(std::string name, const std::type_info& baseType, TypeInfo::CreateFunction f);
/**
* @brief The name the type is registered under (derived from type_info).
* @SINCE_1_0.0
* @return The registered name or empty if unregistered
*/
- const std::string RegisteredName() const;
+ const std::string& RegisteredName() const;
private:
TypeRegistry mReference; ///< Reference to the type registry
- std::string mName; ///< Name of the type
+ std::string mName; ///< Name of the type
};
/**
* @param[in] name The signal name
* @param[in] func The signal connector function
*/
- SignalConnectorType( TypeRegistration& typeRegistration, const std::string& name, TypeInfo::SignalConnectorFunction func );
+ SignalConnectorType(TypeRegistration& typeRegistration, std::string name, TypeInfo::SignalConnectorFunction func);
};
/**
* @param[in] name The action name
* @param[in] f The action function
*/
- TypeAction( TypeRegistration ®istered, const std::string &name, TypeInfo::ActionFunction f);
+ TypeAction(TypeRegistration& registered, std::string name, TypeInfo::ActionFunction f);
};
/**
class DALI_CORE_API PropertyRegistration
{
public:
-
/**
* @brief This constructor registers the property with the registered type.
*
* @note "getFunc" MUST be provided.
*
*/
- PropertyRegistration( TypeRegistration& registered,
- const std::string& name, Property::Index index, Property::Type type,
- TypeInfo::SetPropertyFunction setFunc, TypeInfo::GetPropertyFunction getFunc );
+ PropertyRegistration(TypeRegistration& registered,
+ std::string name,
+ Property::Index index,
+ Property::Type type,
+ TypeInfo::SetPropertyFunction setFunc,
+ TypeInfo::GetPropertyFunction getFunc);
};
/**
class DALI_CORE_API AnimatablePropertyRegistration
{
public:
-
/**
* @brief This constructor registers the animatable property with the registered type.
*
* @param[in] type The property value type
* @pre "registered" must be registered with the TypeRegistry.
*/
- AnimatablePropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type );
+ AnimatablePropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type);
/**
* @brief This constructor registers the animatable property with the registered default value.
* @param[in] value The property default value
* @pre "registered" must be registered with the TypeRegistry.
*/
- AnimatablePropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, const Property::Value& value );
+ AnimatablePropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, const Property::Value& value);
};
/**
class DALI_CORE_API AnimatablePropertyComponentRegistration
{
public:
-
/**
* @brief This constructor registers a component of an animatable property where
* the base animatable property must be a property that supports property component
* @param[in] componentIndex The index of the component (e.g. 0 for the x component of a Vector2 property and 1 for the y component of a Vector2 property)
* @pre "registered" must be registered with the TypeRegistry.
*/
- AnimatablePropertyComponentRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex );
+ AnimatablePropertyComponentRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Index baseIndex, uint32_t componentIndex);
};
/**
class DALI_CORE_API ChildPropertyRegistration
{
public:
-
/**
* @brief This constructor registers an event-thread only child property (i.e. a property
* that the parent supports in its children) with the registered type.
* @param[in] type The property value type
* @pre "registered" must be registered with the TypeRegistry.
*/
- ChildPropertyRegistration( TypeRegistration& registered, const std::string& name, Property::Index index, Property::Type type );
+ ChildPropertyRegistration(TypeRegistration& registered, std::string name, Property::Index index, Property::Type type);
/**
* @brief This constructor registers an event-thread only child property (i.e. a property
* @param[in] type The property value type
* @pre "registered" must be registered with the TypeRegistry.
*/
- ChildPropertyRegistration( const std::string& registered, const std::string& name, Property::Index index, Property::Type type );
+ ChildPropertyRegistration(std::string registered, std::string name, Property::Index index, Property::Type type);
};
-
/**
* @}
*/
namespace Dali
{
-
struct WeakHandleBase::Impl : public BaseObject::Impl::Observer
{
// Construction
Impl()
- : mObject( nullptr )
+ : mObject(nullptr)
{
}
// Construction
- Impl( BaseHandle& handle )
- : mObject( nullptr )
+ Impl(BaseHandle& handle)
+ : mObject(nullptr)
{
- if( handle )
+ if(handle)
{
- mObject = static_cast<Dali::BaseObject*>( handle.GetObjectPtr() );
- if( mObject )
+ mObject = static_cast<Dali::BaseObject*>(handle.GetObjectPtr());
+ if(mObject)
{
- BaseObject::Impl::Get( *mObject ).AddObserver( *this );
+ BaseObject::Impl::Get(*mObject).AddObserver(*this);
}
}
}
// Destruction
- ~Impl()
+ ~Impl() override
{
Reset();
}
void Reset()
{
- if( mObject )
+ if(mObject)
{
- BaseObject::Impl::Get( *mObject ).RemoveObserver( *this );
+ BaseObject::Impl::Get(*mObject).RemoveObserver(*this);
mObject = nullptr;
}
}
/**
* From BaseObject::Impl::Observer
*/
- virtual void ObjectDestroyed( BaseObject& object )
+ void ObjectDestroyed(BaseObject& object) override
{
mObject = nullptr;
}
};
WeakHandleBase::WeakHandleBase()
-: mImpl( new Impl() )
+: mImpl(new Impl())
{
}
-WeakHandleBase::WeakHandleBase( BaseHandle& handle )
-: mImpl( new Impl( handle ) )
+WeakHandleBase::WeakHandleBase(BaseHandle& handle)
+: mImpl(new Impl(handle))
{
}
}
WeakHandleBase::WeakHandleBase(const WeakHandleBase& handle)
-: mImpl( nullptr )
+: mImpl(nullptr)
{
BaseHandle object = handle.GetBaseHandle();
- mImpl = new Impl(object);
+ mImpl = new Impl(object);
}
-WeakHandleBase& WeakHandleBase::operator=( const WeakHandleBase& rhs )
+WeakHandleBase& WeakHandleBase::operator=(const WeakHandleBase& rhs)
{
- if( this != &rhs )
+ if(this != &rhs)
{
delete mImpl;
BaseHandle handle = rhs.GetBaseHandle();
- mImpl = new Impl(handle);
+ mImpl = new Impl(handle);
}
return *this;
}
-WeakHandleBase::WeakHandleBase( WeakHandleBase&& rhs )
-: mImpl( rhs.mImpl )
+WeakHandleBase::WeakHandleBase(WeakHandleBase&& rhs)
+: mImpl(rhs.mImpl)
{
rhs.mImpl = nullptr;
}
-WeakHandleBase& WeakHandleBase::operator=( WeakHandleBase&& rhs )
+WeakHandleBase& WeakHandleBase::operator=(WeakHandleBase&& rhs)
{
- if (this != &rhs)
+ if(this != &rhs)
{
delete mImpl;
- mImpl = rhs.mImpl;
+ mImpl = rhs.mImpl;
rhs.mImpl = nullptr;
}
return *this;
}
-bool WeakHandleBase::operator==( const WeakHandleBase& rhs ) const
+bool WeakHandleBase::operator==(const WeakHandleBase& rhs) const
{
return this->mImpl->mObject == rhs.mImpl->mObject;
}
-bool WeakHandleBase::operator!=( const WeakHandleBase& rhs ) const
+bool WeakHandleBase::operator!=(const WeakHandleBase& rhs) const
{
- return !( *this == rhs );
+ return !(*this == rhs);
}
BaseHandle WeakHandleBase::GetBaseHandle() const
{
- return mImpl ? BaseHandle( mImpl->mObject ) : BaseHandle();
+ return mImpl ? BaseHandle(mImpl->mObject) : BaseHandle();
}
void WeakHandleBase::Reset()
mImpl->Reset();
}
-
-} // Dali
+} // namespace Dali
*/
// INTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/actors/custom-actor.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
*/
class DALI_CORE_API WeakHandleBase
{
-
public:
-
/**
* @brief Default constructor which provides an uninitialized Dali::WeakHandleBase.
* @SINCE_1_2.60
* @SINCE_1_2.60
* @param [in] handle A reference to the handle of the DALi object
*/
- WeakHandleBase( BaseHandle& handle );
+ WeakHandleBase(BaseHandle& handle);
/**
* @brief Destructor to free resources.
* @param [in] rhs A reference to the copied WeakHandleBase
* @return A reference to this WeakHandleBase
*/
- WeakHandleBase& operator=( const WeakHandleBase& rhs );
+ WeakHandleBase& operator=(const WeakHandleBase& rhs);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- WeakHandleBase( WeakHandleBase&& rhs );
+ WeakHandleBase(WeakHandleBase&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- WeakHandleBase& operator=( WeakHandleBase&& rhs );
+ WeakHandleBase& operator=(WeakHandleBase&& rhs);
/**
* @brief Equality operator overload.
*/
void Reset();
-
protected:
-
/// @cond internal
struct Impl;
Impl* mImpl;
/// @endcond
};
-
/**
* @brief Weak handle for the given type of DALi object.
* @SINCE_1_2.60
* @see WeakHandleBase
*/
-template < class T >
+template<class T>
class WeakHandle : public WeakHandleBase
{
public:
-
/**
* @copydoc Dali::WeakHandleBase::WeakHandleBase()
*/
/**
* @copydoc Dali::WeakHandleBase::WeakHandleBase( BaseHandle& )
*/
- WeakHandle( T& handle )
- : WeakHandleBase( handle )
+ WeakHandle(T& handle)
+ : WeakHandleBase(handle)
{
}
/**
* @copydoc Dali::WeakHandleBase::~WeakHandleBase()
*/
- ~WeakHandle() {}
+ ~WeakHandle()
+ {
+ }
/**
* @copydoc Dali::WeakHandleBase::WeakHandleBase(const WeakHandleBase&)
*/
WeakHandle(const WeakHandle& handle)
- : WeakHandleBase( handle )
+ : WeakHandleBase(handle)
{
}
/**
* @copydoc Dali::WeakHandleBase::operator=(const WeakHandleBase& rhs)
*/
- WeakHandle& operator=( const WeakHandle& rhs )
+ WeakHandle& operator=(const WeakHandle& rhs)
{
WeakHandleBase::operator=(rhs);
return *this;
/**
* @copydoc Dali::WeakHandleBase::WeakHandleBase(WeakHandleBase&& rhs)
*/
- WeakHandle( WeakHandle&& rhs ) = default;
+ WeakHandle(WeakHandle&& rhs) = default;
/**
* @copydoc Dali::WeakHandleBase::operator=(WeakHandleBase&& rhs)
*/
- WeakHandle& operator=( WeakHandle&& rhs ) = default;
+ WeakHandle& operator=(WeakHandle&& rhs) = default;
/**
* @copydoc Dali::WeakHandleBase::operator==()
*/
T GetHandle() const
{
- BaseHandle handle( WeakHandleBase::GetBaseHandle() );
- if( handle )
+ BaseHandle handle(WeakHandleBase::GetBaseHandle());
+ if(handle)
{
- return DownCast< T >( handle );
+ return DownCast<T>(handle);
}
else
{
namespace Dali
{
-
RenderTaskList::RenderTaskList()
{
}
-RenderTaskList RenderTaskList::DownCast( BaseHandle handle )
+RenderTaskList RenderTaskList::DownCast(BaseHandle handle)
{
- return RenderTaskList( dynamic_cast<Dali::Internal::RenderTaskList*>( handle.GetObjectPtr() ) );
+ return RenderTaskList(dynamic_cast<Dali::Internal::RenderTaskList*>(handle.GetObjectPtr()));
}
RenderTaskList::~RenderTaskList()
RenderTaskList& RenderTaskList::operator=(const RenderTaskList& rhs) = default;
-RenderTaskList::RenderTaskList( RenderTaskList&& rhs ) = default;
+RenderTaskList::RenderTaskList(RenderTaskList&& rhs) = default;
-RenderTaskList& RenderTaskList::operator=( RenderTaskList&& rhs ) = default;
+RenderTaskList& RenderTaskList::operator=(RenderTaskList&& rhs) = default;
RenderTask RenderTaskList::CreateTask()
{
- return RenderTask( GetImplementation(*this).CreateTask().Get() );
+ return RenderTask(GetImplementation(*this).CreateTask().Get());
}
-void RenderTaskList::RemoveTask( RenderTask task )
+void RenderTaskList::RemoveTask(RenderTask task)
{
- if( task ) // don't crash if called with empty task handle
+ if(task) // don't crash if called with empty task handle
{
- GetImplementation(*this).RemoveTask( GetImplementation( task ) );
+ GetImplementation(*this).RemoveTask(GetImplementation(task));
}
}
return GetImplementation(*this).GetTaskCount();
}
-RenderTask RenderTaskList::GetTask( uint32_t index ) const
+RenderTask RenderTaskList::GetTask(uint32_t index) const
{
- return RenderTask( GetImplementation(*this).GetTask( index ).Get() );
+ return RenderTask(GetImplementation(*this).GetTask(index).Get());
}
-RenderTaskList::RenderTaskList( Internal::RenderTaskList* internal )
-: BaseHandle( internal )
+RenderTaskList::RenderTaskList(Internal::RenderTaskList* internal)
+: BaseHandle(internal)
{
}
} // namespace Dali
-
class DALI_CORE_API RenderTaskList : public BaseHandle
{
public:
-
/**
* @brief Creates an empty RenderTaskList handle.
*
* @param[in] handle A handle to an object
* @return A handle to a RenderTaskList or an uninitialized handle
*/
- static RenderTaskList DownCast( BaseHandle handle );
+ static RenderTaskList DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- RenderTaskList( RenderTaskList&& rhs );
+ RenderTaskList(RenderTaskList&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- RenderTaskList& operator=( RenderTaskList&& rhs );
+ RenderTaskList& operator=(RenderTaskList&& rhs);
/**
* @brief Creates a new RenderTask.
* @SINCE_1_0.0
* @param[in] task The render-task to remove.
*/
- void RemoveTask( RenderTask task );
+ void RemoveTask(RenderTask task);
/**
* @brief Queries the number of render-tasks in the list.
* @return A handle to the render-task
* @pre index should be in range i.e. less than GetTaskCount().
*/
- RenderTask GetTask( uint32_t index ) const;
+ RenderTask GetTask(uint32_t index) const;
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali New() methods.
* @SINCE_1_0.0
* @param [in] renderTask A pointer to a newly allocated render-task
*/
- explicit DALI_INTERNAL RenderTaskList( Internal::RenderTaskList* renderTask );
+ explicit DALI_INTERNAL RenderTaskList(Internal::RenderTaskList* renderTask);
/// @endcond
};
#include <dali/public-api/render-tasks/render-task.h>
// INTERNAL INCLUDES
-#include <dali/public-api/common/constants.h>
-#include <dali/public-api/rendering/frame-buffer.h>
#include <dali/internal/event/actors/actor-impl.h>
#include <dali/internal/event/actors/camera-actor-impl.h>
#include <dali/internal/event/render-tasks/render-task-impl.h>
+#include <dali/public-api/common/constants.h>
+#include <dali/public-api/rendering/frame-buffer.h>
namespace Dali
{
-
-static bool DefaultScreenToFrameBufferFunction( Vector2& coordinates )
+static bool DefaultScreenToFrameBufferFunction(Vector2& coordinates)
{
return false;
}
-static bool FullScreenFrameBufferFunction( Vector2& coordinates )
+static bool FullScreenFrameBufferFunction(Vector2& coordinates)
{
// Don't need to modify frameBufferCoords
return true;
const bool RenderTask::DEFAULT_EXCLUSIVE = false;
const bool RenderTask::DEFAULT_INPUT_ENABLED = true;
-const Vector4 RenderTask::DEFAULT_CLEAR_COLOR = Vector4( 0.0f, 0.0f, 0.0f, 1.0f ); // cannot use Color::Black because it may or may not be initialized yet
+const Vector4 RenderTask::DEFAULT_CLEAR_COLOR = Vector4(0.0f, 0.0f, 0.0f, 1.0f); // cannot use Color::Black because it may or may not be initialized yet
const bool RenderTask::DEFAULT_CLEAR_ENABLED = false;
const bool RenderTask::DEFAULT_CULL_MODE = true;
const uint32_t RenderTask::DEFAULT_REFRESH_RATE = REFRESH_ALWAYS;
{
}
-RenderTask RenderTask::DownCast( BaseHandle handle )
+RenderTask RenderTask::DownCast(BaseHandle handle)
{
- return RenderTask( dynamic_cast<Dali::Internal::RenderTask*>( handle.GetObjectPtr() ) );
+ return RenderTask(dynamic_cast<Dali::Internal::RenderTask*>(handle.GetObjectPtr()));
}
RenderTask::~RenderTask()
RenderTask& RenderTask::operator=(const RenderTask& rhs) = default;
-RenderTask::RenderTask( RenderTask&& rhs ) = default;
+RenderTask::RenderTask(RenderTask&& rhs) = default;
-RenderTask& RenderTask::operator=( RenderTask&& rhs ) = default;
+RenderTask& RenderTask::operator=(RenderTask&& rhs) = default;
-void RenderTask::SetSourceActor( Actor actor )
+void RenderTask::SetSourceActor(Actor actor)
{
// NULL handle is allowed
- Internal::Actor* actorImpl( NULL );
- if ( actor )
+ Internal::Actor* actorImpl(nullptr);
+ if(actor)
{
- actorImpl = &GetImplementation( actor );
+ actorImpl = &GetImplementation(actor);
}
- GetImplementation(*this).SetSourceActor( actorImpl );
+ GetImplementation(*this).SetSourceActor(actorImpl);
}
Actor RenderTask::GetSourceActor() const
return Dali::Actor(GetImplementation(*this).GetSourceActor());
}
-void RenderTask::SetExclusive( bool exclusive )
+void RenderTask::SetExclusive(bool exclusive)
{
- GetImplementation(*this).SetExclusive( exclusive );
+ GetImplementation(*this).SetExclusive(exclusive);
}
bool RenderTask::IsExclusive() const
return GetImplementation(*this).IsExclusive();
}
-void RenderTask::SetCameraActor( CameraActor cameraActor )
+void RenderTask::SetCameraActor(CameraActor cameraActor)
{
// NULL handle is allowed
- Internal::CameraActor* actorImpl( NULL );
- if ( cameraActor )
+ Internal::CameraActor* actorImpl(nullptr);
+ if(cameraActor)
{
- actorImpl = &GetImplementation( cameraActor );
+ actorImpl = &GetImplementation(cameraActor);
}
- GetImplementation(*this).SetCameraActor( actorImpl );
+ GetImplementation(*this).SetCameraActor(actorImpl);
}
CameraActor RenderTask::GetCameraActor() const
return Dali::CameraActor(GetImplementation(*this).GetCameraActor());
}
-void RenderTask::SetFrameBuffer( FrameBuffer frameBuffer )
+void RenderTask::SetFrameBuffer(FrameBuffer frameBuffer)
{
- Internal::FrameBuffer* frameBufferPtr( NULL );
- if( frameBuffer )
+ Internal::FrameBuffer* frameBufferPtr(nullptr);
+ if(frameBuffer)
{
- frameBufferPtr = &GetImplementation( frameBuffer );
+ frameBufferPtr = &GetImplementation(frameBuffer);
}
- GetImplementation(*this).SetFrameBuffer( frameBufferPtr );
+ GetImplementation(*this).SetFrameBuffer(frameBufferPtr);
}
FrameBuffer RenderTask::GetFrameBuffer() const
{
- Internal::FrameBuffer* frameBufferPtr( GetImplementation(*this).GetFrameBuffer() );
- return FrameBuffer( frameBufferPtr );
+ Internal::FrameBuffer* frameBufferPtr(GetImplementation(*this).GetFrameBuffer());
+ return FrameBuffer(frameBufferPtr);
}
-void RenderTask::SetScreenToFrameBufferFunction( ScreenToFrameBufferFunction conversionFunction )
+void RenderTask::SetScreenToFrameBufferFunction(ScreenToFrameBufferFunction conversionFunction)
{
- GetImplementation(*this).SetScreenToFrameBufferFunction( conversionFunction );
+ GetImplementation(*this).SetScreenToFrameBufferFunction(conversionFunction);
}
RenderTask::ScreenToFrameBufferFunction RenderTask::GetScreenToFrameBufferFunction() const
return GetImplementation(*this).GetScreenToFrameBufferFunction();
}
-void RenderTask::SetScreenToFrameBufferMappingActor( Dali::Actor mappingActor )
+void RenderTask::SetScreenToFrameBufferMappingActor(Dali::Actor mappingActor)
{
- GetImplementation(*this).SetScreenToFrameBufferMappingActor( mappingActor );
+ GetImplementation(*this).SetScreenToFrameBufferMappingActor(mappingActor);
}
Dali::Actor RenderTask::GetScreenToFrameBufferMappingActor() const
return GetImplementation(*this).GetScreenToFrameBufferMappingActor();
}
-void RenderTask::SetViewportPosition( Vector2 position )
+void RenderTask::SetViewportPosition(Vector2 position)
{
- GetImplementation(*this).SetViewportPosition( position );
+ GetImplementation(*this).SetViewportPosition(position);
}
Vector2 RenderTask::GetCurrentViewportPosition() const
return GetImplementation(*this).GetCurrentViewportPosition();
}
-void RenderTask::SetViewportSize( Vector2 size )
+void RenderTask::SetViewportSize(Vector2 size)
{
- GetImplementation(*this).SetViewportSize( size );
+ GetImplementation(*this).SetViewportSize(size);
}
Vector2 RenderTask::GetCurrentViewportSize() const
return GetImplementation(*this).GetCurrentViewportSize();
}
-void RenderTask::SetViewport( Viewport viewport )
+void RenderTask::SetViewport(Viewport viewport)
{
- GetImplementation(*this).SetViewport( viewport );
+ GetImplementation(*this).SetViewport(viewport);
}
Viewport RenderTask::GetViewport() const
{
Viewport result;
- GetImplementation(*this).GetViewport( result );
+ GetImplementation(*this).GetViewport(result);
return result;
}
-void RenderTask::SetClearColor( const Vector4& color )
+void RenderTask::SetClearColor(const Vector4& color)
{
- GetImplementation(*this).SetClearColor( color );
+ GetImplementation(*this).SetClearColor(color);
}
Vector4 RenderTask::GetClearColor() const
return GetImplementation(*this).GetClearColor();
}
-void RenderTask::SetClearEnabled( bool enabled )
+void RenderTask::SetClearEnabled(bool enabled)
{
- GetImplementation(*this).SetClearEnabled( enabled );
+ GetImplementation(*this).SetClearEnabled(enabled);
}
bool RenderTask::GetClearEnabled() const
return GetImplementation(*this).GetClearEnabled();
}
-void RenderTask::SetCullMode( bool mode )
+void RenderTask::SetCullMode(bool mode)
{
- GetImplementation(*this).SetCullMode( mode );
+ GetImplementation(*this).SetCullMode(mode);
}
bool RenderTask::GetCullMode() const
return GetImplementation(*this).GetCullMode();
}
-void RenderTask::SetRefreshRate( uint32_t refreshRate )
+void RenderTask::SetRefreshRate(uint32_t refreshRate)
{
- GetImplementation(*this).SetRefreshRate( refreshRate );
+ GetImplementation(*this).SetRefreshRate(refreshRate);
}
uint32_t RenderTask::GetRefreshRate() const
return GetImplementation(*this).FinishedSignal();
}
-void RenderTask::SetInputEnabled( bool enabled )
+void RenderTask::SetInputEnabled(bool enabled)
{
- GetImplementation(*this).SetInputEnabled( enabled );
+ GetImplementation(*this).SetInputEnabled(enabled);
}
bool RenderTask::GetInputEnabled() const
return GetImplementation(*this).GetInputEnabled();
}
-bool RenderTask::WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const
+bool RenderTask::WorldToViewport(const Vector3& position, float& viewportX, float& viewportY) const
{
return GetImplementation(*this).WorldToViewport(position, viewportX, viewportY);
}
-bool RenderTask::ViewportToLocal(Actor actor, float viewportX, float viewportY, float &localX, float &localY) const
+bool RenderTask::ViewportToLocal(Actor actor, float viewportX, float viewportY, float& localX, float& localY) const
{
- if( actor )
+ if(actor)
{
- Internal::Actor* actorImpl( &GetImplementation( actor ) );
- return GetImplementation(*this).ViewportToLocal( actorImpl, viewportX, viewportY, localX, localY );
+ Internal::Actor* actorImpl(&GetImplementation(actor));
+ return GetImplementation(*this).ViewportToLocal(actorImpl, viewportX, viewportY, localX, localY);
}
else
{
}
}
-
-RenderTask::RenderTask( Internal::RenderTask* internal )
+RenderTask::RenderTask(Internal::RenderTask* internal)
: Handle(internal)
{
}
class DALI_CORE_API RenderTask : public Handle
{
public:
-
/**
* @brief Enumeration for instances of properties belonging to the RenderTask class.
* @SINCE_1_0.0
* @brief Typedef for signals sent by this class.
* @SINCE_1_0.0
*/
- typedef Signal< void (RenderTask& source) > RenderTaskSignalType;
+ using RenderTaskSignalType = Signal<void(RenderTask&)>;
/**
* @brief A pointer to a function for converting screen to frame-buffer coordinates.
* @param[in,out] coordinates The screen coordinates to convert where (0,0) is the top-left of the screen
* @return True if the conversion was successful, otherwise coordinates should be unmodified
*/
- typedef bool (* ScreenToFrameBufferFunction)( Vector2& coordinates );
+ using ScreenToFrameBufferFunction = bool (*)(Vector2&);
/**
* @brief A pointer to a function for converting screen to frame-buffer coordinates.
* @param[in,out] coordinates The screen coordinates to convert where (0,0) is the top-left of the screen
* @return True if the conversion was successful, otherwise coordinates should be unmodified
*/
- typedef bool (* const ConstScreenToFrameBufferFunction)( Vector2& coordinates );
+ using ConstScreenToFrameBufferFunction = bool (*const)(Vector2&);
/**
* @brief The default conversion function returns false for any screen coordinates.
* @param[in] handle A handle to an object
* @return A handle to a RenderTask or an uninitialized handle
*/
- static RenderTask DownCast( BaseHandle handle );
+ static RenderTask DownCast(BaseHandle handle);
/**
* @brief Destructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- RenderTask( RenderTask&& rhs );
+ RenderTask(RenderTask&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- RenderTask& operator=( RenderTask&& rhs );
+ RenderTask& operator=(RenderTask&& rhs);
/**
* @brief Sets the actors to be rendered.
* @param[in] actor This actor and its children will be rendered.
* If actor is an empty handle, then nothing will be rendered
*/
- void SetSourceActor( Actor actor );
+ void SetSourceActor(Actor actor);
/**
* @brief Retrieves the actors to be rendered.
* @SINCE_1_0.0
* @param[in] exclusive True if the source actors will only be rendered by this render-task
*/
- void SetExclusive( bool exclusive );
+ void SetExclusive(bool exclusive);
/**
* @brief Queries whether the RenderTask has exclusive access to the source actors.
* @SINCE_1_0.0
* @param[in] enabled True if the render-task should be considered for input handling
*/
- void SetInputEnabled( bool enabled );
+ void SetInputEnabled(bool enabled);
/**
* @brief Queries whether the render-task should be considered for input handling.
* @SINCE_1_0.0
* @param[in] cameraActor The scene is viewed from the perspective of this actor
*/
- void SetCameraActor( CameraActor cameraActor );
+ void SetCameraActor(CameraActor cameraActor);
/**
* @brief Retrieves the actor from which the scene is viewed.
* @SINCE_1_1.38
* @param[in] frameBuffer A valid FrameBuffer handle to enable off-screen rendering, or an uninitialized handle to disable it
*/
- void SetFrameBuffer( FrameBuffer frameBuffer );
+ void SetFrameBuffer(FrameBuffer frameBuffer);
/**
* @brief Retrieves the frame-buffer used as a render target.
* @SINCE_1_0.0
* @param[in] conversionFunction The conversion function
*/
- void SetScreenToFrameBufferFunction( ScreenToFrameBufferFunction conversionFunction );
+ void SetScreenToFrameBufferFunction(ScreenToFrameBufferFunction conversionFunction);
/**
* @brief Retrieves the function used to convert screen coordinates to frame-buffer coordinates.
* @param[in] mappingActor The actor used for conversion
* @note The mapping actor needs to be rendered by the default render task to make the mapping work properly.
*/
- void SetScreenToFrameBufferMappingActor( Actor mappingActor );
+ void SetScreenToFrameBufferMappingActor(Actor mappingActor);
/**
* @brief Retrieves the actor used to convert screen coordinates to frame-buffer coordinates.
* @param[in] position The viewports position (x,y)
* @note Unlike the glViewport method, the x & y coordinates refer to the top-left of the viewport rectangle.
*/
- void SetViewportPosition( Vector2 position );
+ void SetViewportPosition(Vector2 position);
/**
* @brief Retrieves the GL viewport position used when rendering.
* @SINCE_1_0.0
* @param[in] size The viewports size (width,height)
*/
- void SetViewportSize( Vector2 size );
+ void SetViewportSize(Vector2 size);
/**
* @brief Retrieves the GL viewport size used when rendering.
* @param[in] viewport The new viewport
* @note Unlike the glViewport method, the x & y coordinates refer to the top-left of the viewport rectangle.
*/
- void SetViewport( Viewport viewport );
+ void SetViewport(Viewport viewport);
/**
* @brief Retrieves the GL viewport used when rendering.
* @SINCE_1_0.0
* @param[in] color The new clear color
*/
- void SetClearColor( const Vector4& color );
+ void SetClearColor(const Vector4& color);
/**
* @brief Retrieves the clear color used when SetClearEnabled(true) is used.
* be (partially) cleared before rendering the second.
*
*/
- void SetClearEnabled( bool enabled );
+ void SetClearEnabled(bool enabled);
/**
* @brief Queries whether the render-task will clear the results of previous render-tasks.
* @note If the shader uses @ref Shader::Hint::MODIFIES_GEOMETRY then culling optimizations are disabled.
* @see Shader::Hint
*/
- void SetCullMode( bool cullMode );
+ void SetCullMode(bool cullMode);
/**
* @brief Gets the cull mode.
* @SINCE_1_0.0
* @param[in] refreshRate The new refresh rate
*/
- void SetRefreshRate( uint32_t refreshRate );
+ void SetRefreshRate(uint32_t refreshRate);
/**
* @brief Queries the refresh-rate of the RenderTask.
* @param[out] viewportY The viewport y position
* @return true if the position has a screen coordinate
*/
- bool WorldToViewport(const Vector3 &position, float& viewportX, float& viewportY) const;
+ bool WorldToViewport(const Vector3& position, float& viewportX, float& viewportY) const;
/**
* @brief Gets actor local coordinates for given viewport coordinates.
* @param[out] localY The local y position
* @return true if the screen position has a local coordinate
*/
- bool ViewportToLocal(Actor actor, float viewportX, float viewportY, float &localX, float &localY) const;
+ bool ViewportToLocal(Actor actor, float viewportX, float viewportY, float& localX, float& localY) const;
public: // Signals
-
/**
* @brief If the refresh rate is REFRESH_ONCE, connect to this signal to be notified when a RenderTask has finished.
* @SINCE_1_0.0
RenderTaskSignalType& FinishedSignal();
public: // Not intended for application developers
-
/// @cond internal
/**
* @brief This constructor is used by Dali New() methods.
* @SINCE_1_0.0
* @param[in] renderTask A pointer to a newly allocated render-task
*/
- explicit DALI_INTERNAL RenderTask( Internal::RenderTask* renderTask );
+ explicit DALI_INTERNAL RenderTask(Internal::RenderTask* renderTask);
/// @endcond
};
#include <type_traits>
// INTERNAL INCLUDES
-#include <dali/integration-api/debug.h> // DALI_LOG_WARNING_NOFN
+#include <dali/integration-api/debug.h> // DALI_LOG_WARNING_NOFN
#include <dali/internal/event/rendering/frame-buffer-impl.h> // Dali::Internal::FrameBuffer
-#include <dali/internal/event/rendering/texture-impl.h> // Dali::Internal::Texture
+#include <dali/internal/event/rendering/texture-impl.h> // Dali::Internal::Texture
namespace Dali
{
-
namespace
{
/// Bool operator for FrameBuffer::Attachment::Mask.
/// in cpp as only used in this file
-bool operator&( FrameBuffer::Attachment::Mask lhs, FrameBuffer::Attachment::Mask rhs )
+bool operator&(FrameBuffer::Attachment::Mask lhs, FrameBuffer::Attachment::Mask rhs)
{
- using UnderlyingType = typename std::underlying_type< FrameBuffer::Attachment::Mask >::type;
- return static_cast<bool>( static_cast<UnderlyingType>( lhs ) & static_cast<UnderlyingType>( rhs ) );
+ using UnderlyingType = typename std::underlying_type<FrameBuffer::Attachment::Mask>::type;
+ return static_cast<bool>(static_cast<UnderlyingType>(lhs) & static_cast<UnderlyingType>(rhs));
}
} // unnamed namespace
-FrameBuffer FrameBuffer::New( uint32_t width, uint32_t height )
+FrameBuffer FrameBuffer::New(uint32_t width, uint32_t height)
{
- return New( width, height, FrameBuffer::Attachment::COLOR );
+ return New(width, height, FrameBuffer::Attachment::COLOR);
}
-FrameBuffer FrameBuffer::New( uint32_t width, uint32_t height, Attachment::Mask attachments )
+FrameBuffer FrameBuffer::New(uint32_t width, uint32_t height, Attachment::Mask attachments)
{
- Internal::FrameBufferPtr frameBuffer = Internal::FrameBuffer::New( width, height, attachments );
- if( attachments & FrameBuffer::Attachment::COLOR )
+ Internal::FrameBufferPtr frameBuffer = Internal::FrameBuffer::New(width, height, attachments);
+ if(attachments & FrameBuffer::Attachment::COLOR)
{
- Internal::TexturePtr texture = Internal::Texture::New( Dali::TextureType::TEXTURE_2D, Pixel::RGB888, width, height );
- frameBuffer->AttachColorTexture( texture, 0u, 0u );
+ Internal::TexturePtr texture = Internal::Texture::New(Dali::TextureType::TEXTURE_2D, Pixel::RGB888, width, height);
+ frameBuffer->AttachColorTexture(texture, 0u, 0u);
}
- return FrameBuffer( frameBuffer.Get() );
+ return FrameBuffer(frameBuffer.Get());
}
FrameBuffer::FrameBuffer()
{
}
-FrameBuffer::FrameBuffer( const FrameBuffer& handle ) = default;
+FrameBuffer::FrameBuffer(const FrameBuffer& handle) = default;
-FrameBuffer FrameBuffer::DownCast( BaseHandle handle )
+FrameBuffer FrameBuffer::DownCast(BaseHandle handle)
{
- return FrameBuffer( dynamic_cast<Dali::Internal::FrameBuffer*>(handle.GetObjectPtr()));
+ return FrameBuffer(dynamic_cast<Dali::Internal::FrameBuffer*>(handle.GetObjectPtr()));
}
-FrameBuffer& FrameBuffer::operator=( const FrameBuffer& handle ) = default;
+FrameBuffer& FrameBuffer::operator=(const FrameBuffer& handle) = default;
-FrameBuffer::FrameBuffer( Internal::FrameBuffer* pointer )
-: BaseHandle( pointer )
+FrameBuffer::FrameBuffer(Internal::FrameBuffer* pointer)
+: BaseHandle(pointer)
{
}
-FrameBuffer::FrameBuffer( FrameBuffer&& rhs ) = default;
+FrameBuffer::FrameBuffer(FrameBuffer&& rhs) = default;
-FrameBuffer& FrameBuffer::operator=( FrameBuffer&& rhs ) = default;
+FrameBuffer& FrameBuffer::operator=(FrameBuffer&& rhs) = default;
-void FrameBuffer::AttachColorTexture( Texture& texture )
+void FrameBuffer::AttachColorTexture(Texture& texture)
{
- AttachColorTexture( texture, 0u, 0u );
+ AttachColorTexture(texture, 0u, 0u);
}
-void FrameBuffer::AttachColorTexture( Texture& texture, uint32_t mipmapLevel, uint32_t layer )
+void FrameBuffer::AttachColorTexture(Texture& texture, uint32_t mipmapLevel, uint32_t layer)
{
- if( texture )
+ if(texture)
{
- Internal::TexturePtr texturePtr( &GetImplementation( texture ) );
- GetImplementation(*this).AttachColorTexture( texturePtr, mipmapLevel, layer );
+ Internal::TexturePtr texturePtr(&GetImplementation(texture));
+ GetImplementation(*this).AttachColorTexture(texturePtr, mipmapLevel, layer);
}
}
Texture FrameBuffer::GetColorTexture()
{
Internal::Texture* texturePtr = GetImplementation(*this).GetColorTexture(0);
- return Dali::Texture( texturePtr );
+ return Dali::Texture(texturePtr);
}
} //namespace Dali
class DALI_CORE_API FrameBuffer : public BaseHandle
{
public:
-
/**
* @brief The initial attachments to create the FrameBuffer with.
* @note The color attachment can also be created on calling AttachColorTexture().
*/
enum Mask
{
- NONE = 0, ///< No attachments are created initially. @SINCE_1_1.45
- DEPTH = 1 << 0, ///< Depth buffer is created. @SINCE_1_1.45
- STENCIL = 1 << 1, ///< Stencil buffer is created. @SINCE_1_1.45
- DEPTH_STENCIL = DEPTH | STENCIL, ///< Depth and stencil buffer are created. @SINCE_1_1.45
- COLOR = 1 << 2, ///< Color texture is created. @SINCE_1_4.0
- COLOR_DEPTH = COLOR | DEPTH, ///< Color texture and depth buffer are created. @SINCE_1_4.0
- COLOR_STENCIL = COLOR | STENCIL, ///< Color texture and stencil buffer are created. @SINCE_1_4.0
+ NONE = 0, ///< No attachments are created initially. @SINCE_1_1.45
+ DEPTH = 1 << 0, ///< Depth buffer is created. @SINCE_1_1.45
+ STENCIL = 1 << 1, ///< Stencil buffer is created. @SINCE_1_1.45
+ DEPTH_STENCIL = DEPTH | STENCIL, ///< Depth and stencil buffer are created. @SINCE_1_1.45
+ COLOR = 1 << 2, ///< Color texture is created. @SINCE_1_4.0
+ COLOR_DEPTH = COLOR | DEPTH, ///< Color texture and depth buffer are created. @SINCE_1_4.0
+ COLOR_STENCIL = COLOR | STENCIL, ///< Color texture and stencil buffer are created. @SINCE_1_4.0
COLOR_DEPTH_STENCIL = COLOR_DEPTH | STENCIL ///< Color, depth and stencil buffer are created. @SINCE_1_4.0
};
};
* @param[in] height The height of the FrameBuffer and the color texture
* @return A handle to a newly allocated FrameBuffer
*/
- static FrameBuffer New( uint32_t width, uint32_t height );
+ static FrameBuffer New(uint32_t width, uint32_t height);
/**
* @brief Creates a new FrameBuffer with specific attachments.
* @param[in] attachments Enumeration of the attachments to create
* @return A handle to a newly allocated FrameBuffer
*/
- static FrameBuffer New( uint32_t width, uint32_t height, Attachment::Mask attachments );
+ static FrameBuffer New(uint32_t width, uint32_t height, Attachment::Mask attachments);
/**
* @brief Default constructor, creates an empty handle.
* @SINCE_1_1.43
* @param[in] handle Handle to an object
*/
- FrameBuffer( const FrameBuffer& handle );
+ FrameBuffer(const FrameBuffer& handle);
/**
* @brief Downcasts to a FrameBuffer.
* @param[in] handle Handle to an object
* @return FrameBuffer handle or an uninitialized handle
*/
- static FrameBuffer DownCast( BaseHandle handle );
+ static FrameBuffer DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- FrameBuffer& operator=( const FrameBuffer& handle );
+ FrameBuffer& operator=(const FrameBuffer& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- FrameBuffer( FrameBuffer&& rhs );
+ FrameBuffer(FrameBuffer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- FrameBuffer& operator=( FrameBuffer&& rhs );
+ FrameBuffer& operator=(FrameBuffer&& rhs);
/**
* @brief Attach the base LOD of a 2D texture to the framebuffer for color rendering.
* @note The texture has to have same size as that of FrameBuffer
* otherwise it won't be attached.
*/
- void AttachColorTexture( Texture& texture );
+ void AttachColorTexture(Texture& texture);
/**
* @brief Attach a texture to the framebuffer for color rendering.
* @note The mipmapped texture has to have same size as that of FrameBuffer
* otherwise it won't be attached.
*/
- void AttachColorTexture( Texture& texture, uint32_t mipmapLevel, uint32_t layer );
+ void AttachColorTexture(Texture& texture, uint32_t mipmapLevel, uint32_t layer);
/**
* @brief Gets the first color texture used as output in the FrameBuffer.
Texture GetColorTexture();
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated FrameBuffer
*/
- explicit DALI_INTERNAL FrameBuffer( Internal::FrameBuffer* pointer );
+ explicit DALI_INTERNAL FrameBuffer(Internal::FrameBuffer* pointer);
};
/**
*/
// CLASS HEADER
-#include <dali/public-api/rendering/geometry.h> // Dali::Geometry
+#include <dali/public-api/rendering/geometry.h> // Dali::Geometry
// INTERNAL INCLUDES
#include <dali/internal/event/rendering/geometry-impl.h> // Dali::Internal::Geometry
namespace Dali
{
-
Geometry Geometry::New()
{
Internal::GeometryPtr geometry = Internal::Geometry::New();
- return Geometry( geometry.Get() );
+ return Geometry(geometry.Get());
}
Geometry::Geometry()
{
}
-Geometry::Geometry( const Geometry& handle ) = default;
+Geometry::Geometry(const Geometry& handle) = default;
-Geometry Geometry::DownCast( BaseHandle handle )
+Geometry Geometry::DownCast(BaseHandle handle)
{
- return Geometry( dynamic_cast<Dali::Internal::Geometry*>(handle.GetObjectPtr()));
+ return Geometry(dynamic_cast<Dali::Internal::Geometry*>(handle.GetObjectPtr()));
}
-Geometry& Geometry::operator=( const Geometry& handle ) = default;
+Geometry& Geometry::operator=(const Geometry& handle) = default;
-Geometry::Geometry( Geometry&& rhs ) = default;
+Geometry::Geometry(Geometry&& rhs) = default;
-Geometry& Geometry::operator=( Geometry&& rhs ) = default;
+Geometry& Geometry::operator=(Geometry&& rhs) = default;
-std::size_t Geometry::AddVertexBuffer( VertexBuffer& vertexBuffer )
+std::size_t Geometry::AddVertexBuffer(VertexBuffer& vertexBuffer)
{
- DALI_ASSERT_ALWAYS( vertexBuffer && "VertexBuffer is not initialized ");
- return GetImplementation(*this).AddVertexBuffer( GetImplementation( vertexBuffer ) );
+ DALI_ASSERT_ALWAYS(vertexBuffer && "VertexBuffer is not initialized ");
+ return GetImplementation(*this).AddVertexBuffer(GetImplementation(vertexBuffer));
}
std::size_t Geometry::GetNumberOfVertexBuffers() const
return GetImplementation(*this).GetNumberOfVertexBuffers();
}
-void Geometry::RemoveVertexBuffer( std::size_t index )
+void Geometry::RemoveVertexBuffer(std::size_t index)
{
- GetImplementation(*this).RemoveVertexBuffer( static_cast<uint32_t>( index ) );
+ GetImplementation(*this).RemoveVertexBuffer(static_cast<uint32_t>(index));
}
-void Geometry::SetIndexBuffer( const uint16_t* indices, size_t count )
+void Geometry::SetIndexBuffer(const uint16_t* indices, size_t count)
{
- GetImplementation(*this).SetIndexBuffer( indices, static_cast<uint32_t>( count ) );
+ GetImplementation(*this).SetIndexBuffer(indices, static_cast<uint32_t>(count));
}
-void Geometry::SetType( Type geometryType )
+void Geometry::SetType(Type geometryType)
{
- GetImplementation(*this).SetType( geometryType );
+ GetImplementation(*this).SetType(geometryType);
}
Geometry::Type Geometry::GetType() const
return GetImplementation(*this).GetType();
}
-Geometry::Geometry( Internal::Geometry* pointer )
-: BaseHandle( pointer )
+Geometry::Geometry(Internal::Geometry* pointer)
+: BaseHandle(pointer)
{
}
#include <cstdint> // uint16_t
// INTERNAL INCLUDES
-#include <dali/public-api/object/handle.h> // Dali::Handle
+#include <dali/public-api/object/handle.h> // Dali::Handle
#include <dali/public-api/object/property-index-ranges.h> // DEFAULT_DERIVED_HANDLE_PROPERTY_START_INDEX
-#include <dali/public-api/rendering/vertex-buffer.h> // Dali::VertexBuffer
+#include <dali/public-api/rendering/vertex-buffer.h> // Dali::VertexBuffer
namespace Dali
{
class DALI_CORE_API Geometry : public BaseHandle
{
public:
-
/**
* @brief Enumeration for the description of the type of geometry, used to determine how the coordinates will be used.
* @SINCE_1_1.45
TRIANGLE_STRIP ///< A strip of triangles (after the first triangle, following triangles need only 1 point) @SINCE_1_1.45
};
-
/**
* @brief Creates a new Geometry object.
*
* @SINCE_1_1.43
* @param[in] handle Handle to an object
*/
- Geometry( const Geometry& handle );
+ Geometry(const Geometry& handle);
/**
* @brief Downcasts to a geometry.
* @param[in] handle Handle to an object
* @return Geometry handle or an uninitialized handle
*/
- static Geometry DownCast( BaseHandle handle );
+ static Geometry DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- Geometry& operator=( const Geometry& handle );
+ Geometry& operator=(const Geometry& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Geometry( Geometry&& rhs );
+ Geometry(Geometry&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Geometry& operator=( Geometry&& rhs );
+ Geometry& operator=(Geometry&& rhs);
/**
* @brief Adds a VertexBuffer to be used as source of geometry vertices.
* @return Index of the newly added buffer, can be used with RemoveVertexBuffer to remove
* this buffer if no longer required
*/
- std::size_t AddVertexBuffer( VertexBuffer& vertexBuffer );
+ std::size_t AddVertexBuffer(VertexBuffer& vertexBuffer);
/**
* @brief Retrieves the number of vertex buffers that have been added to this geometry.
* @SINCE_1_9.27
* @param[in] index Index to the vertex buffer to remove
*/
- void RemoveVertexBuffer( std::size_t index );
+ void RemoveVertexBuffer(std::size_t index);
/**
* @brief Sets a the index data to be used as a source of indices for the geometry
* @param[in] indices Array of indices
* @param[in] count Number of indices in the array
*/
- void SetIndexBuffer( const uint16_t* indices, size_t count );
+ void SetIndexBuffer(const uint16_t* indices, size_t count);
/**
* @brief Sets the type of primitives this geometry contains.
* @SINCE_1_1.43
* @param[in] geometryType Type of primitives this geometry contains
*/
- void SetType( Type geometryType );
+ void SetType(Type geometryType);
/**
* @brief Gets the type of primitives this geometry contains.
Type GetType() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated Geometry
*/
- explicit DALI_INTERNAL Geometry( Internal::Geometry* pointer );
+ explicit DALI_INTERNAL Geometry(Internal::Geometry* pointer);
};
/**
*/
// CLASS HEADER
-#include <dali/public-api/rendering/renderer.h> // Dali::Renderer
+#include <dali/public-api/rendering/renderer.h> // Dali::Renderer
// INTERNAL INCLUDES
#include <dali/internal/event/rendering/renderer-impl.h> // Dali::Internal::Renderer
namespace Dali
{
-
-Renderer Renderer::New( Geometry& geometry, Shader& shader )
+Renderer Renderer::New(Geometry& geometry, Shader& shader)
{
- Internal::RendererPtr renderer = Internal::Renderer::New( );
- renderer->SetGeometry( GetImplementation(geometry) );
- renderer->SetShader( GetImplementation(shader) );
- return Renderer( renderer.Get() );
+ Internal::RendererPtr renderer = Internal::Renderer::New();
+ renderer->SetGeometry(GetImplementation(geometry));
+ renderer->SetShader(GetImplementation(shader));
+ return Renderer(renderer.Get());
}
Renderer::Renderer()
{
}
-Renderer::Renderer( const Renderer& handle ) = default;
+Renderer::Renderer(const Renderer& handle) = default;
-Renderer Renderer::DownCast( BaseHandle handle )
+Renderer Renderer::DownCast(BaseHandle handle)
{
- return Renderer( dynamic_cast<Dali::Internal::Renderer*>(handle.GetObjectPtr()));
+ return Renderer(dynamic_cast<Dali::Internal::Renderer*>(handle.GetObjectPtr()));
}
-Renderer& Renderer::operator=( const Renderer& handle ) = default;
+Renderer& Renderer::operator=(const Renderer& handle) = default;
-Renderer::Renderer( Renderer&& rhs ) = default;
+Renderer::Renderer(Renderer&& rhs) = default;
-Renderer& Renderer::operator=( Renderer&& rhs ) = default;
+Renderer& Renderer::operator=(Renderer&& rhs) = default;
-void Renderer::SetGeometry( Geometry& geometry )
+void Renderer::SetGeometry(Geometry& geometry)
{
- DALI_ASSERT_ALWAYS( geometry && "Geometry handle not initialized" );
- GetImplementation(*this).SetGeometry( GetImplementation(geometry) );
+ DALI_ASSERT_ALWAYS(geometry && "Geometry handle not initialized");
+ GetImplementation(*this).SetGeometry(GetImplementation(geometry));
}
Geometry Renderer::GetGeometry() const
{
- return Dali::Geometry( GetImplementation(*this).GetGeometry().Get() );
+ return Dali::Geometry(GetImplementation(*this).GetGeometry().Get());
}
-void Renderer::SetTextures( TextureSet& textureSet )
+void Renderer::SetTextures(TextureSet& textureSet)
{
- DALI_ASSERT_ALWAYS( textureSet && "TextureSet handle not initialized" );
- GetImplementation(*this).SetTextures( GetImplementation(textureSet) );
+ DALI_ASSERT_ALWAYS(textureSet && "TextureSet handle not initialized");
+ GetImplementation(*this).SetTextures(GetImplementation(textureSet));
}
TextureSet Renderer::GetTextures() const
{
- return Dali::TextureSet( GetImplementation(*this).GetTextures().Get() );
+ return Dali::TextureSet(GetImplementation(*this).GetTextures().Get());
}
-void Renderer::SetShader( Shader& shader )
+void Renderer::SetShader(Shader& shader)
{
- DALI_ASSERT_ALWAYS( shader && "Shader handle not initialized" );
- GetImplementation(*this).SetShader( GetImplementation(shader) );
+ DALI_ASSERT_ALWAYS(shader && "Shader handle not initialized");
+ GetImplementation(*this).SetShader(GetImplementation(shader));
}
Shader Renderer::GetShader() const
{
- return Dali::Shader( GetImplementation(*this).GetShader().Get() );
+ return Dali::Shader(GetImplementation(*this).GetShader().Get());
}
-Renderer::Renderer( Internal::Renderer* pointer )
-: Handle( pointer )
+Renderer::Renderer(Internal::Renderer* pointer)
+: Handle(pointer)
{
}
namespace FaceCullingMode
{
-
/**
* @brief Enumeration for face culling mode.
* @SINCE_1_1.43
*/
enum Type
{
- NONE, ///< None of the faces should be culled @SINCE_1_1.43
- FRONT, ///< Cull front face, front faces should never be shown @SINCE_1_1.43
- BACK, ///< Cull back face, back faces should never be shown @SINCE_1_1.43
- FRONT_AND_BACK, ///< Cull front and back faces; if the geometry is composed of triangles none of the faces will be shown @SINCE_1_1.43
+ NONE, ///< None of the faces should be culled @SINCE_1_1.43
+ FRONT, ///< Cull front face, front faces should never be shown @SINCE_1_1.43
+ BACK, ///< Cull back face, back faces should never be shown @SINCE_1_1.43
+ FRONT_AND_BACK, ///< Cull front and back faces; if the geometry is composed of triangles none of the faces will be shown @SINCE_1_1.43
};
} // namespace FaceCullingMode
namespace BlendMode
{
-
/**
* @brief Enumeration for blend mode.
* @SINCE_1_1.43
namespace BlendEquation
{
-
/**
* @brief Enumeration for blend equation.
* @SINCE_1_1.43
*/
enum Type
{
- ADD = 0x8006, ///< The source and destination colors are added to each other. @SINCE_1_1.43
- SUBTRACT = 0x800A, ///< Subtracts the destination from the source. @SINCE_1_1.43
- REVERSE_SUBTRACT = 0x800B ///< Subtracts the source from the destination. @SINCE_1_1.43
+ ADD = 0x8006, ///< The source and destination colors are added to each other. @SINCE_1_1.43
+ SUBTRACT = 0x800A, ///< Subtracts the destination from the source. @SINCE_1_1.43
+ REVERSE_SUBTRACT = 0x800B ///< Subtracts the source from the destination. @SINCE_1_1.43
};
} // namespace BlendEquation
namespace BlendFactor
{
-
/**
* @brief Enumeration for blend factor.
* @SINCE_1_1.43
namespace DepthWriteMode
{
-
/**
* @brief Enumeration for depth buffer write modes.
* @SINCE_1_1.43
namespace DepthTestMode
{
-
/**
* @brief Enumeration for depth buffer test (read) modes.
* @SINCE_1_1.43
namespace DepthFunction
{
-
/**
* @brief Enumeration for depth functions.
* @SINCE_1_1.43
namespace RenderMode
{
-
/**
* @brief Enumeration for the controls of how this renderer uses its stencil properties and writes to the color buffer.
* @SINCE_1_2_5
namespace StencilFunction
{
-
/**
* @brief Enumeration for the comparison function used on the stencil buffer.
* @SINCE_1_1.43
namespace StencilOperation
{
-
/**
* @brief Enumeration for specifying the action to take when the stencil (or depth) test fails during stencil test.
* @SINCE_1_1.43
} // namespace StencilOperation
-
/**
* @brief Renderer is a handle to an object used to show content by combining a Geometry, a TextureSet and a shader.
*
class DALI_CORE_API Renderer : public Handle
{
public:
-
/**
* @brief Enumeration for instances of properties belonging to the Renderer class.
* @SINCE_1_1.43
* @param[in] shader Shader to be used by this renderer
* @return A handle to the Renderer
*/
- static Renderer New( Geometry& geometry, Shader& shader );
+ static Renderer New(Geometry& geometry, Shader& shader);
/**
* @brief Default constructor, creates an empty handle
* @SINCE_1_1.43
* @param[in] handle Handle to an object
*/
- Renderer( const Renderer& handle );
+ Renderer(const Renderer& handle);
/**
* @brief Downcasts to a renderer handle.
* @param[in] handle Handle to an object
* @return Renderer handle or an uninitialized handle
*/
- static Renderer DownCast( BaseHandle handle );
+ static Renderer DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- Renderer& operator=( const Renderer& handle );
+ Renderer& operator=(const Renderer& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Renderer( Renderer&& rhs );
+ Renderer(Renderer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Renderer& operator=( Renderer&& rhs );
+ Renderer& operator=(Renderer&& rhs);
/**
* @brief Sets the geometry to be used by this renderer.
* @SINCE_1_1.43
* @param[in] geometry The geometry to be used by this renderer
*/
- void SetGeometry( Geometry& geometry );
+ void SetGeometry(Geometry& geometry);
/**
* @brief Gets the geometry used by this renderer.
* @param[in] firstElement The First element to draw
* @param[in] elementsCount The number of elements to draw
*/
- inline void SetIndexRange( int firstElement, int elementsCount )
+ inline void SetIndexRange(int firstElement, int elementsCount)
{
- SetProperty( Property::INDEX_RANGE_FIRST, firstElement );
- SetProperty( Property::INDEX_RANGE_COUNT, elementsCount );
+ SetProperty(Property::INDEX_RANGE_FIRST, firstElement);
+ SetProperty(Property::INDEX_RANGE_COUNT, elementsCount);
}
/**
* @SINCE_1_1.43
* @param[in] textureSet The texture set to be used by this renderer
*/
- void SetTextures( TextureSet& textureSet );
+ void SetTextures(TextureSet& textureSet);
/**
* @brief Gets the texture set used by this renderer.
* @SINCE_1_1.43
* @param[in] shader The shader to be used by this renderer
*/
- void SetShader( Shader& shader );
+ void SetShader(Shader& shader);
/**
* @brief Gets the shader used by this renderer.
Shader GetShader() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated Renderer
*/
- explicit DALI_INTERNAL Renderer( Internal::Renderer* pointer );
+ explicit DALI_INTERNAL Renderer(Internal::Renderer* pointer);
};
/**
*/
// CLASS HEADER
-#include <dali/public-api/rendering/sampler.h> // Dali::Sampler
+#include <dali/public-api/rendering/sampler.h> // Dali::Sampler
// INTERNAL INCLUDES
#include <dali/internal/event/rendering/sampler-impl.h> // Dali::Internal::Sampler
namespace Dali
{
-
Sampler Sampler::New()
{
Internal::SamplerPtr sampler = Internal::Sampler::New();
- return Sampler( sampler.Get() );
+ return Sampler(sampler.Get());
}
Sampler::Sampler()
{
}
-Sampler::Sampler( const Sampler& handle ) = default;
+Sampler::Sampler(const Sampler& handle) = default;
-Sampler Sampler::DownCast( BaseHandle handle )
+Sampler Sampler::DownCast(BaseHandle handle)
{
- return Sampler( dynamic_cast<Dali::Internal::Sampler*>(handle.GetObjectPtr()));
+ return Sampler(dynamic_cast<Dali::Internal::Sampler*>(handle.GetObjectPtr()));
}
-Sampler& Sampler::operator=( const Sampler& handle ) = default;
+Sampler& Sampler::operator=(const Sampler& handle) = default;
-Sampler::Sampler( Sampler&& rhs ) = default;
+Sampler::Sampler(Sampler&& rhs) = default;
-Sampler& Sampler::operator=( Sampler&& rhs ) = default;
+Sampler& Sampler::operator=(Sampler&& rhs) = default;
-void Sampler::SetFilterMode( FilterMode::Type minFilter, FilterMode::Type magFilter )
+void Sampler::SetFilterMode(FilterMode::Type minFilter, FilterMode::Type magFilter)
{
- GetImplementation(*this).SetFilterMode( minFilter, magFilter );
+ GetImplementation(*this).SetFilterMode(minFilter, magFilter);
}
-void Sampler::SetWrapMode( WrapMode::Type uWrap, WrapMode::Type vWrap )
+void Sampler::SetWrapMode(WrapMode::Type uWrap, WrapMode::Type vWrap)
{
- GetImplementation(*this).SetWrapMode( uWrap, uWrap, vWrap );
+ GetImplementation(*this).SetWrapMode(uWrap, uWrap, vWrap);
}
-void Sampler::SetWrapMode( WrapMode::Type rWrap, WrapMode::Type sWrap, WrapMode::Type tWrap )
+void Sampler::SetWrapMode(WrapMode::Type rWrap, WrapMode::Type sWrap, WrapMode::Type tWrap)
{
- GetImplementation(*this).SetWrapMode( rWrap, sWrap, tWrap );
+ GetImplementation(*this).SetWrapMode(rWrap, sWrap, tWrap);
}
Sampler::Sampler(Internal::Sampler* pointer)
-: BaseHandle( pointer )
+: BaseHandle(pointer)
{
}
*/
// INTERNAL INCLUDES
-#include <dali/public-api/object/handle.h> // Dali::Handle
#include <dali/public-api/actors/sampling.h>
+#include <dali/public-api/object/handle.h> // Dali::Handle
namespace Dali
{
class DALI_CORE_API Sampler : public BaseHandle
{
public:
-
/**
* @brief Creates a new Sampler object.
*
* @SINCE_1_1.43
* @param[in] handle Handle to an object
*/
- Sampler( const Sampler& handle );
+ Sampler(const Sampler& handle);
/**
* @brief Downcasts to a sampler handle.
* @param[in] handle Handle to an object
* @return Handle or an uninitialized handle
*/
- static Sampler DownCast( BaseHandle handle );
+ static Sampler DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- Sampler& operator=( const Sampler& handle );
-
+ Sampler& operator=(const Sampler& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Sampler( Sampler&& rhs );
+ Sampler(Sampler&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Sampler& operator=( Sampler&& rhs );
+ Sampler& operator=(Sampler&& rhs);
/**
* @brief Sets the filter modes for this sampler.
* @param[in] minFilter The minification filter that will be used
* @param[in] magFilter The magnification filter that will be used
*/
- void SetFilterMode( FilterMode::Type minFilter, FilterMode::Type magFilter );
+ void SetFilterMode(FilterMode::Type minFilter, FilterMode::Type magFilter);
/**
* @brief Sets the wrap modes for this sampler.
* @param[in] uWrap Wrap mode for u coordinates
* @param[in] vWrap Wrap mode for v coordinates
*/
- void SetWrapMode( WrapMode::Type uWrap, WrapMode::Type vWrap );
+ void SetWrapMode(WrapMode::Type uWrap, WrapMode::Type vWrap);
/**
* @brief Sets the wrap modes for this sampler.
* @param[in] sWrap Wrap mode for the x direction
* @param[in] tWrap Wrap mode for the y direction
*/
- void SetWrapMode( WrapMode::Type rWrap, WrapMode::Type sWrap, WrapMode::Type tWrap );
+ void SetWrapMode(WrapMode::Type rWrap, WrapMode::Type sWrap, WrapMode::Type tWrap);
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated Sampler
*/
- explicit DALI_INTERNAL Sampler( Internal::Sampler* pointer );
+ explicit DALI_INTERNAL Sampler(Internal::Sampler* pointer);
};
/**
*/
// CLASS HEADER
-#include <dali/public-api/rendering/shader.h> // Dali::Shader
+#include <dali/public-api/rendering/shader.h> // Dali::Shader
// INTERNAL INCLUDES
-#include <dali/internal/event/rendering/shader-impl.h> // Dali::Internal::Shader
+#include <dali/internal/event/rendering/shader-impl.h> // Dali::Internal::Shader
namespace Dali
{
-
-Shader Shader::New( const std::string& vertexShader,
- const std::string& fragmentShader,
- Hint::Value hints )
+Shader Shader::New(const std::string& vertexShader,
+ const std::string& fragmentShader,
+ Hint::Value hints)
{
- Internal::ShaderPtr renderer = Internal::Shader::New( vertexShader, fragmentShader, hints );
- return Shader( renderer.Get() );
+ Internal::ShaderPtr renderer = Internal::Shader::New(vertexShader, fragmentShader, hints);
+ return Shader(renderer.Get());
}
Shader::Shader()
{
}
-Shader::Shader( const Shader& handle ) = default;
+Shader::Shader(const Shader& handle) = default;
-Shader Shader::DownCast( BaseHandle handle )
+Shader Shader::DownCast(BaseHandle handle)
{
- return Shader( dynamic_cast<Dali::Internal::Shader*>(handle.GetObjectPtr()));
+ return Shader(dynamic_cast<Dali::Internal::Shader*>(handle.GetObjectPtr()));
}
-Shader& Shader::operator=( const Shader& handle ) = default;
+Shader& Shader::operator=(const Shader& handle) = default;
-Shader::Shader( Shader&& rhs ) = default;
+Shader::Shader(Shader&& rhs) = default;
-Shader& Shader::operator=( Shader&& rhs ) = default;
+Shader& Shader::operator=(Shader&& rhs) = default;
-Shader::Shader( Internal::Shader* pointer )
-: Handle( pointer )
+Shader::Shader(Internal::Shader* pointer)
+: Handle(pointer)
{
}
class DALI_CORE_API Shader : public Handle
{
public:
-
/**
* @brief Hints for rendering.
* @SINCE_1_1.45
*/
enum Value
{
- NONE = 0x00, ///< No hints @SINCE_1_1.45
- OUTPUT_IS_TRANSPARENT = 0x01, ///< Might generate transparent alpha from opaque inputs @SINCE_1_1.45
- MODIFIES_GEOMETRY = 0x02, ///< Might change position of vertices, this option disables any culling optimizations @SINCE_1_1.45
+ NONE = 0x00, ///< No hints @SINCE_1_1.45
+ OUTPUT_IS_TRANSPARENT = 0x01, ///< Might generate transparent alpha from opaque inputs @SINCE_1_1.45
+ MODIFIES_GEOMETRY = 0x02, ///< Might change position of vertices, this option disables any culling optimizations @SINCE_1_1.45
};
};
* @param[in] hints Hints to define the geometry of the rendered object
* @return A handle to a shader effect
*/
- static Shader New( const std::string& vertexShader,
- const std::string& fragmentShader,
- Hint::Value hints = Hint::NONE );
+ static Shader New(const std::string& vertexShader,
+ const std::string& fragmentShader,
+ Hint::Value hints = Hint::NONE);
/**
* @brief Default constructor, creates an empty handle.
* @SINCE_1_1.43
* @param[in] handle A handle to a Shader object
*/
- Shader( const Shader& handle );
+ Shader(const Shader& handle);
/**
* @brief Downcasts to a shader handle.
* @param[in] handle Handle to an object
* @return Shader handle or an uninitialized handle
*/
- static Shader DownCast( BaseHandle handle );
+ static Shader DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- Shader& operator=( const Shader& handle );
+ Shader& operator=(const Shader& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Shader( Shader&& rhs );
+ Shader(Shader&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this
*/
- Shader& operator=( Shader&& rhs );
+ Shader& operator=(Shader&& rhs);
public:
-
/**
* @brief This constructor is used by Dali New() methods.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] effect A pointer to a newly allocated Dali resource.
*/
- explicit DALI_INTERNAL Shader( Internal::Shader* effect );
+ explicit DALI_INTERNAL Shader(Internal::Shader* effect);
};
/**
*/
// CLASS HEADER
-#include <dali/public-api/rendering/texture-set.h> // Dali::TextureSet
+#include <dali/public-api/rendering/texture-set.h> // Dali::TextureSet
// INTERNAL INCLUDES
-#include <dali/internal/event/rendering/texture-set-impl.h> // Dali::Internal::TextureSet
#include <dali/internal/event/rendering/sampler-impl.h> // Dali::Internal::Sampler
#include <dali/internal/event/rendering/shader-impl.h> // Dali::Internal::Shader
+#include <dali/internal/event/rendering/texture-set-impl.h> // Dali::Internal::TextureSet
namespace Dali
{
-
TextureSet TextureSet::New()
{
Internal::TextureSetPtr textureSet = Internal::TextureSet::New();
- return TextureSet( textureSet.Get() );
+ return TextureSet(textureSet.Get());
}
TextureSet::TextureSet()
{
}
-TextureSet::TextureSet( const TextureSet& handle ) = default;
+TextureSet::TextureSet(const TextureSet& handle) = default;
-TextureSet TextureSet::DownCast( BaseHandle handle )
+TextureSet TextureSet::DownCast(BaseHandle handle)
{
- return TextureSet( dynamic_cast<Dali::Internal::TextureSet*>(handle.GetObjectPtr()));
+ return TextureSet(dynamic_cast<Dali::Internal::TextureSet*>(handle.GetObjectPtr()));
}
-TextureSet& TextureSet::operator=( const TextureSet& handle ) = default;
+TextureSet& TextureSet::operator=(const TextureSet& handle) = default;
-TextureSet::TextureSet( TextureSet&& rhs ) = default;
+TextureSet::TextureSet(TextureSet&& rhs) = default;
-TextureSet& TextureSet::operator=( TextureSet&& rhs ) = default;
+TextureSet& TextureSet::operator=(TextureSet&& rhs) = default;
-void TextureSet::SetTexture( size_t index, Texture texture )
+void TextureSet::SetTexture(size_t index, Texture texture)
{
- if( texture )
+ if(texture)
{
- Internal::TexturePtr texturePtr( &GetImplementation( texture ) );
- GetImplementation(*this).SetTexture( static_cast<uint32_t>( index ), texturePtr ); // only support 4,294,967,295 textures
+ Internal::TexturePtr texturePtr(&GetImplementation(texture));
+ GetImplementation(*this).SetTexture(static_cast<uint32_t>(index), texturePtr); // only support 4,294,967,295 textures
}
else
{
- GetImplementation(*this).SetTexture( static_cast<uint32_t>( index ), NULL ); // only support 4,294,967,295 textures
+ GetImplementation(*this).SetTexture(static_cast<uint32_t>(index), nullptr); // only support 4,294,967,295 textures
}
}
-Texture TextureSet::GetTexture( size_t index ) const
+Texture TextureSet::GetTexture(size_t index) const
{
- Internal::Texture* texturePtr = GetImplementation(*this).GetTexture( static_cast<uint32_t>( index ) ); // only support 4,294,967,295 textures
- return Dali::Texture( texturePtr );
+ Internal::Texture* texturePtr = GetImplementation(*this).GetTexture(static_cast<uint32_t>(index)); // only support 4,294,967,295 textures
+ return Dali::Texture(texturePtr);
}
-void TextureSet::SetSampler( size_t index, Sampler sampler )
+void TextureSet::SetSampler(size_t index, Sampler sampler)
{
- if( sampler )
+ if(sampler)
{
- Internal::SamplerPtr samplerPtr( &GetImplementation( sampler ) );
- GetImplementation(*this).SetSampler( static_cast<uint32_t>( index ), samplerPtr ); // only support 4,294,967,295 samplers
+ Internal::SamplerPtr samplerPtr(&GetImplementation(sampler));
+ GetImplementation(*this).SetSampler(static_cast<uint32_t>(index), samplerPtr); // only support 4,294,967,295 samplers
}
else
{
- GetImplementation(*this).SetSampler( static_cast<uint32_t>( index ), NULL ); // only support 4,294,967,295 samplers
+ GetImplementation(*this).SetSampler(static_cast<uint32_t>(index), nullptr); // only support 4,294,967,295 samplers
}
}
-Sampler TextureSet::GetSampler( size_t index ) const
+Sampler TextureSet::GetSampler(size_t index) const
{
- Internal::Sampler* samplerPtr = GetImplementation(*this).GetSampler( static_cast<uint32_t>( index ) ); // only support 4,294,967,295 samplers
- return Dali::Sampler( samplerPtr );
+ Internal::Sampler* samplerPtr = GetImplementation(*this).GetSampler(static_cast<uint32_t>(index)); // only support 4,294,967,295 samplers
+ return Dali::Sampler(samplerPtr);
}
size_t TextureSet::GetTextureCount() const
return GetImplementation(*this).GetTextureCount();
}
-TextureSet::TextureSet( Internal::TextureSet* pointer )
-: BaseHandle( pointer )
+TextureSet::TextureSet(Internal::TextureSet* pointer)
+: BaseHandle(pointer)
{
}
class DALI_CORE_API TextureSet : public BaseHandle
{
public:
-
/**
* @brief Creates a new TextureSet object.
*
* @SINCE_1_1.43
* @param[in] handle Handle to an object
*/
- TextureSet( const TextureSet& handle );
+ TextureSet(const TextureSet& handle);
/**
* @brief Downcasts to a TextureSet handle.
* @param[in] handle Handle to an object
* @return TextureSet handle or an uninitialized handle
*/
- static TextureSet DownCast( BaseHandle handle );
+ static TextureSet DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return A reference to this
*/
- TextureSet& operator=( const TextureSet& handle );
+ TextureSet& operator=(const TextureSet& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- TextureSet( TextureSet&& rhs );
+ TextureSet(TextureSet&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- TextureSet& operator=( TextureSet&& rhs );
+ TextureSet& operator=(TextureSet&& rhs);
/**
* @brief Sets the texture at position "index".
* @param[in] index The position in the texture set of the texture
* @param[in] texture The texture
*/
- void SetTexture( size_t index, Texture texture );
+ void SetTexture(size_t index, Texture texture);
/**
* @brief Gets the image at position "index".
* @param[in] index The position in the texture set of the image
* @return A handle to the image at the the specified position
*/
- Texture GetTexture( size_t index ) const;
+ Texture GetTexture(size_t index) const;
/**
* @brief Sets the sampler to be used by the image at position "index".
* @param[in] index The position in the texture set of the sampler
* @param[in] sampler The sampler to use
*/
- void SetSampler( size_t index, Sampler sampler );
+ void SetSampler(size_t index, Sampler sampler);
/**
* @brief Sets the sampler to be used by the image at position "index".
* @param[in] index The position in the texture set of the image
* @return A handle to the sampler at the specified position
*/
- Sampler GetSampler( size_t index ) const;
+ Sampler GetSampler(size_t index) const;
/**
* @brief Gets the number of textures present in the TextureSet.
size_t GetTextureCount() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated TextureSet
*/
- explicit DALI_INTERNAL TextureSet( Internal::TextureSet* pointer );
+ explicit DALI_INTERNAL TextureSet(Internal::TextureSet* pointer);
};
/**
*/
} //namespace Dali
-
#endif // DALI_TEXTURE_SET_H
*/
// CLASS HEADER
-#include <dali/public-api/rendering/texture.h> // Dali::Texture
+#include <dali/public-api/rendering/texture.h> // Dali::Texture
// INTERNAL INCLUDES
-#include <dali/internal/event/rendering/texture-impl.h> // Dali::Internal::Texture
#include <dali/internal/event/images/pixel-data-impl.h> // Dali::Internal::PixelData
-
+#include <dali/internal/event/rendering/texture-impl.h> // Dali::Internal::Texture
namespace Dali
{
-
-Texture Texture::New( TextureType::Type type, Pixel::Format format, uint32_t width, uint32_t height )
+Texture Texture::New(TextureType::Type type, Pixel::Format format, uint32_t width, uint32_t height)
{
- Internal::TexturePtr texture = Internal::Texture::New(type, format, width, height );
- return Texture( texture.Get() );
+ Internal::TexturePtr texture = Internal::Texture::New(type, format, width, height);
+ return Texture(texture.Get());
}
-Texture Texture::New( NativeImageInterface& nativeImageInterface )
+Texture Texture::New(NativeImageInterface& nativeImageInterface)
{
- Internal::TexturePtr texture = Internal::Texture::New( nativeImageInterface );
- return Texture( texture.Get() );
+ Internal::TexturePtr texture = Internal::Texture::New(nativeImageInterface);
+ return Texture(texture.Get());
}
Texture::Texture()
{
}
-Texture::Texture( const Texture& handle ) = default;
+Texture::Texture(const Texture& handle) = default;
-Texture Texture::DownCast( BaseHandle handle )
+Texture Texture::DownCast(BaseHandle handle)
{
- return Texture( dynamic_cast<Dali::Internal::Texture*>(handle.GetObjectPtr()));
+ return Texture(dynamic_cast<Dali::Internal::Texture*>(handle.GetObjectPtr()));
}
-Texture& Texture::operator=( const Texture& handle ) = default;
+Texture& Texture::operator=(const Texture& handle) = default;
-Texture::Texture( Texture&& rhs ) = default;
+Texture::Texture(Texture&& rhs) = default;
-Texture& Texture::operator=( Texture&& rhs ) = default;
+Texture& Texture::operator=(Texture&& rhs) = default;
-bool Texture::Upload( PixelData pixelData )
+bool Texture::Upload(PixelData pixelData)
{
- Internal::PixelData& internalPixelData = GetImplementation( pixelData );
- return GetImplementation(*this).Upload( &internalPixelData );
+ Internal::PixelData& internalPixelData = GetImplementation(pixelData);
+ return GetImplementation(*this).Upload(&internalPixelData);
}
-bool Texture::Upload( PixelData pixelData,
- uint32_t layer, uint32_t mipmap,
- uint32_t xOffset, uint32_t yOffset,
- uint32_t width, uint32_t height )
+bool Texture::Upload(PixelData pixelData,
+ uint32_t layer,
+ uint32_t mipmap,
+ uint32_t xOffset,
+ uint32_t yOffset,
+ uint32_t width,
+ uint32_t height)
{
- Internal::PixelData& internalPixelData = GetImplementation( pixelData );
- return GetImplementation(*this).Upload( &internalPixelData, layer, mipmap, xOffset, yOffset, width, height );
+ Internal::PixelData& internalPixelData = GetImplementation(pixelData);
+ return GetImplementation(*this).Upload(&internalPixelData, layer, mipmap, xOffset, yOffset, width, height);
}
void Texture::GenerateMipmaps()
return GetImplementation(*this).GetHeight();
}
-Texture::Texture( Internal::Texture* pointer )
-: BaseHandle( pointer )
+Texture::Texture(Internal::Texture* pointer)
+: BaseHandle(pointer)
{
}
*/
// INTERNAL INCLUDES
-#include <dali/public-api/object/base-handle.h>
#include <dali/public-api/images/native-image-interface.h>
-#include <dali/public-api/images/pixel.h>
#include <dali/public-api/images/pixel-data.h>
+#include <dali/public-api/images/pixel.h>
+#include <dali/public-api/object/base-handle.h>
namespace Dali
{
namespace TextureType
{
-
/**
* @brief Enumeration for texture types.
* @SINCE_1_1.43
*/
enum Type
{
- TEXTURE_2D, ///< One 2D image @SINCE_1_1.43
- TEXTURE_CUBE ///< Six 2D images arranged in a cube-shape @SINCE_1_1.43
+ TEXTURE_2D, ///< One 2D image @SINCE_1_1.43
+ TEXTURE_CUBE ///< Six 2D images arranged in a cube-shape @SINCE_1_1.43
};
} // namespace TextureType
namespace CubeMapLayer
{
-
- /**
+/**
* @brief Faces of a cube map.
* These constants should be used as the "layer" parameter when uploading a cube-map with Texture::Upload.
* @SINCE_1_1.43
*/
- const uint32_t POSITIVE_X = 0u; ///< CubeMap image for +x @SINCE_1_1.43
- const uint32_t NEGATIVE_X = 1u; ///< CubeMap image for -x @SINCE_1_1.43
- const uint32_t POSITIVE_Y = 2u; ///< CubeMap image for +y @SINCE_1_1.43
- const uint32_t NEGATIVE_Y = 3u; ///< CubeMap image for -y @SINCE_1_1.43
- const uint32_t POSITIVE_Z = 4u; ///< CubeMap image for +z @SINCE_1_1.43
- const uint32_t NEGATIVE_Z = 5u; ///< CubeMap image for -z @SINCE_1_1.43
+const uint32_t POSITIVE_X = 0u; ///< CubeMap image for +x @SINCE_1_1.43
+const uint32_t NEGATIVE_X = 1u; ///< CubeMap image for -x @SINCE_1_1.43
+const uint32_t POSITIVE_Y = 2u; ///< CubeMap image for +y @SINCE_1_1.43
+const uint32_t NEGATIVE_Y = 3u; ///< CubeMap image for -y @SINCE_1_1.43
+const uint32_t POSITIVE_Z = 4u; ///< CubeMap image for +z @SINCE_1_1.43
+const uint32_t NEGATIVE_Z = 5u; ///< CubeMap image for -z @SINCE_1_1.43
} // namespace CubeMapLayer
-
/**
* @brief Texture represents a texture object used as input or output by shaders.
* @SINCE_1_1.43
class DALI_CORE_API Texture : public BaseHandle
{
public:
-
/**
* @brief Creates a new Texture object.
*
* @param[in] height The height of the texture
* @return A handle to a newly allocated Texture
*/
- static Texture New( TextureType::Type type, Pixel::Format format, uint32_t width, uint32_t height );
+ static Texture New(TextureType::Type type, Pixel::Format format, uint32_t width, uint32_t height);
/**
* @brief Creates a new Texture object from a native image.
* @note It is not possible to upload data to textures created from a native image using Upload methods
* although there might be platform specific APIs to upload data to a native image.
*/
- static Texture New( NativeImageInterface& nativeImageInterface );
+ static Texture New(NativeImageInterface& nativeImageInterface);
/**
* @brief Default constructor, creates an empty handle.
* @SINCE_1_1.43
* @param[in] handle Handle to an object
*/
- Texture( const Texture& handle );
+ Texture(const Texture& handle);
/**
* @brief Downcasts to a texture.
* @param[in] handle Handle to an object
* @return Texture handle or an uninitialized handle
*/
- static Texture DownCast( BaseHandle handle );
+ static Texture DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- Texture& operator=( const Texture& handle );
+ Texture& operator=(const Texture& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.22
* @param[in] rhs A reference to the moved handle
*/
- Texture( Texture&& rhs );
+ Texture(Texture&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- Texture& operator=( Texture&& rhs );
+ Texture& operator=(Texture&& rhs);
/**
* @brief Uploads data to the texture from a PixelData object.
* @param[in] pixelData The pixelData object
* @return True if the PixelData object has compatible pixel format and fits within the texture, false otherwise
*/
- bool Upload( PixelData pixelData );
+ bool Upload(PixelData pixelData);
/**
* @brief Uploads data to the texture from a PixelData object.
* @param[in] height Specifies the height of the rectangular area in the texture that will be updated
* @return True if the PixelData object has compatible pixel format and fits in the rectangle specified, false otherwise
*/
- bool Upload( PixelData pixelData,
- uint32_t layer, uint32_t mipmap,
- uint32_t xOffset, uint32_t yOffset,
- uint32_t width, uint32_t height );
+ bool Upload(PixelData pixelData,
+ uint32_t layer,
+ uint32_t mipmap,
+ uint32_t xOffset,
+ uint32_t yOffset,
+ uint32_t width,
+ uint32_t height);
/**
* @brief Generates mipmaps for the texture.
uint32_t GetHeight() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_1.43
* @param[in] pointer A pointer to a newly allocated Texture
*/
- explicit DALI_INTERNAL Texture( Internal::Texture* pointer );
+ explicit DALI_INTERNAL Texture(Internal::Texture* pointer);
};
/**
#include <dali/public-api/rendering/vertex-buffer.h>
// INTERNAL INCLUDES
-#include <dali/public-api/object/property-map.h> // Dali::Property::Map
#include <dali/internal/event/rendering/vertex-buffer-impl.h> // Dali::Internal::VertexBuffer
+#include <dali/public-api/object/property-map.h> // Dali::Property::Map
namespace Dali
{
-
-VertexBuffer VertexBuffer::New( Dali::Property::Map& bufferFormat )
+VertexBuffer VertexBuffer::New(Dali::Property::Map& bufferFormat)
{
- Internal::VertexBufferPtr vertexBuffer = Internal::VertexBuffer::New( bufferFormat );
+ Internal::VertexBufferPtr vertexBuffer = Internal::VertexBuffer::New(bufferFormat);
- return VertexBuffer( vertexBuffer.Get() );
+ return VertexBuffer(vertexBuffer.Get());
}
VertexBuffer::VertexBuffer()
{
}
-VertexBuffer::VertexBuffer( const VertexBuffer& handle ) = default;
+VertexBuffer::VertexBuffer(const VertexBuffer& handle) = default;
-VertexBuffer VertexBuffer::DownCast( BaseHandle handle )
+VertexBuffer VertexBuffer::DownCast(BaseHandle handle)
{
- return VertexBuffer( dynamic_cast<Dali::Internal::VertexBuffer*>(handle.GetObjectPtr()));
+ return VertexBuffer(dynamic_cast<Dali::Internal::VertexBuffer*>(handle.GetObjectPtr()));
}
-VertexBuffer& VertexBuffer::operator=( const VertexBuffer& handle ) = default;
+VertexBuffer& VertexBuffer::operator=(const VertexBuffer& handle) = default;
-VertexBuffer::VertexBuffer( VertexBuffer&& rhs ) = default;
+VertexBuffer::VertexBuffer(VertexBuffer&& rhs) = default;
-VertexBuffer& VertexBuffer::operator=( VertexBuffer&& rhs ) = default;
+VertexBuffer& VertexBuffer::operator=(VertexBuffer&& rhs) = default;
-void VertexBuffer::SetData( const void* data, std::size_t size )
+void VertexBuffer::SetData(const void* data, std::size_t size)
{
- GetImplementation(*this).SetData( data, static_cast<uint32_t>( size ) ); // only support 4,294,967,295 bytes
+ GetImplementation(*this).SetData(data, static_cast<uint32_t>(size)); // only support 4,294,967,295 bytes
}
std::size_t VertexBuffer::GetSize() const
{
- return GetImplementation(*this).GetSize();
+ return GetImplementation(*this).GetSize();
}
-
-VertexBuffer::VertexBuffer( Internal::VertexBuffer* pointer )
-: BaseHandle( pointer )
+VertexBuffer::VertexBuffer(Internal::VertexBuffer* pointer)
+: BaseHandle(pointer)
{
}
class DALI_CORE_API VertexBuffer : public BaseHandle
{
public:
-
/**
* @brief Creates a VertexBuffer.
*
* @param[in] bufferFormat Map of names and types that describes the components of the buffer
* @return Handle to a newly allocated VertexBuffer
*/
- static VertexBuffer New( Dali::Property::Map& bufferFormat );
+ static VertexBuffer New(Dali::Property::Map& bufferFormat);
/**
* @brief Default constructor, creates an empty handle.
* @SINCE_1_9.27
* @param[in] handle Handle to an object
*/
- VertexBuffer( const VertexBuffer& handle );
+ VertexBuffer(const VertexBuffer& handle);
/**
* @brief Downcasts to a property buffer handle.
* @param[in] handle Handle to an object
* @return Property buffer handle or an uninitialized handle
*/
- static VertexBuffer DownCast( BaseHandle handle );
+ static VertexBuffer DownCast(BaseHandle handle);
/**
* @brief Assignment operator, changes this handle to point at the same object.
* @param[in] handle Handle to an object
* @return Reference to the assigned object
*/
- VertexBuffer& operator=( const VertexBuffer& handle );
+ VertexBuffer& operator=(const VertexBuffer& handle);
/**
* @brief Move constructor.
* @SINCE_1_9.27
* @param[in] rhs A reference to the moved handle
*/
- VertexBuffer( VertexBuffer&& rhs );
+ VertexBuffer(VertexBuffer&& rhs);
/**
* @brief Move assignment operator.
* @param[in] rhs A reference to the moved handle
* @return A reference to this handle
*/
- VertexBuffer& operator=( VertexBuffer&& rhs );
+ VertexBuffer& operator=(VertexBuffer&& rhs);
/**
* @brief Updates the whole buffer information.
* @param[in] data A pointer to the data that will be copied to the buffer
* @param[in] size Number of elements to expand or contract the buffer
*/
- void SetData( const void* data, std::size_t size );
+ void SetData(const void* data, std::size_t size);
/**
* @brief Gets the number of elements in the buffer.
std::size_t GetSize() const;
public:
-
/**
* @brief The constructor.
* @note Not intended for application developers.
* @SINCE_1_9.27
* @param[in] pointer A pointer to a newly allocated VertexBuffer
*/
- explicit DALI_INTERNAL VertexBuffer( Internal::VertexBuffer* pointer );
+ explicit DALI_INTERNAL VertexBuffer(Internal::VertexBuffer* pointer);
};
/**
/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace
{
-
const int32_t INVALID_CALLBACK_INDEX = -1;
} // unnamed namespace
namespace Dali
{
-
BaseSignal::BaseSignal()
-: mEmittingFlag( false )
+: mEmittingFlag(false)
{
}
BaseSignal::~BaseSignal()
{
// We can't assert in a destructor
- if( mEmittingFlag )
+ if(mEmittingFlag)
{
- DALI_LOG_ERROR( "Invalid destruction of Signal during Emit()\n" );
+ DALI_LOG_ERROR("Invalid destruction of Signal during Emit()\n");
}
// The signal is being destroyed. We have to inform any slots
// that are connected, that the signal is dead.
- const std::size_t count( mSignalConnections.Count() );
- for( std::size_t i=0; i < count; i++ )
+ const std::size_t count(mSignalConnections.Count());
+ for(std::size_t i = 0; i < count; i++)
{
- SignalConnection* connection = mSignalConnections[ i ];
+ SignalConnection* connection = mSignalConnections[i];
// Note that values are set to NULL in DeleteConnection
- if( connection )
+ if(connection)
{
- connection->Disconnect( this );
+ connection->Disconnect(this);
delete connection;
}
}
bool BaseSignal::Empty() const
{
- return ( 0 == GetConnectionCount() );
+ return (0 == GetConnectionCount());
}
std::size_t BaseSignal::GetConnectionCount() const
{
- std::size_t count( 0 );
+ std::size_t count(0);
- const std::size_t size( mSignalConnections.Count() );
- for( std::size_t i = 0; i < size; ++i )
+ const std::size_t size(mSignalConnections.Count());
+ for(std::size_t i = 0; i < size; ++i)
{
// Note that values are set to NULL in DeleteConnection
- if ( NULL != mSignalConnections[i] )
+ if(nullptr != mSignalConnections[i])
{
++count;
}
void BaseSignal::Emit()
{
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that mSignalConnections.Count() count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- CallbackBase::Execute( *callback );
+ CallbackBase::Execute(*callback);
}
}
CleanupConnections();
}
-void BaseSignal::OnConnect( CallbackBase* callback )
+void BaseSignal::OnConnect(CallbackBase* callback)
{
- DALI_ASSERT_ALWAYS( NULL != callback && "Invalid member function pointer passed to Connect()" );
+ DALI_ASSERT_ALWAYS(nullptr != callback && "Invalid member function pointer passed to Connect()");
- int32_t index = FindCallback( callback );
+ int32_t index = FindCallback(callback);
// Don't double-connect the same callback
- if( INVALID_CALLBACK_INDEX == index )
+ if(INVALID_CALLBACK_INDEX == index)
{
// create a new signal connection object, to allow the signal to track the connection.
- SignalConnection* connection = new SignalConnection( callback );
+ SignalConnection* connection = new SignalConnection(callback);
- mSignalConnections.PushBack( connection );
+ mSignalConnections.PushBack(connection);
}
else
{
}
}
-void BaseSignal::OnDisconnect( CallbackBase* callback )
+void BaseSignal::OnDisconnect(CallbackBase* callback)
{
- DALI_ASSERT_ALWAYS( NULL != callback && "Invalid member function pointer passed to Disconnect()" );
+ DALI_ASSERT_ALWAYS(nullptr != callback && "Invalid member function pointer passed to Disconnect()");
- int32_t index = FindCallback( callback );
+ int32_t index = FindCallback(callback);
- if( index > INVALID_CALLBACK_INDEX )
+ if(index > INVALID_CALLBACK_INDEX)
{
- DeleteConnection( index );
+ DeleteConnection(index);
}
// call back is a temporary created to find which slot should be disconnected.
delete callback;
}
-void BaseSignal::OnConnect( ConnectionTrackerInterface* tracker, CallbackBase* callback )
+void BaseSignal::OnConnect(ConnectionTrackerInterface* tracker, CallbackBase* callback)
{
- DALI_ASSERT_ALWAYS( NULL != tracker && "Invalid ConnectionTrackerInterface pointer passed to Connect()" );
- DALI_ASSERT_ALWAYS( NULL != callback && "Invalid member function pointer passed to Connect()" );
+ DALI_ASSERT_ALWAYS(nullptr != tracker && "Invalid ConnectionTrackerInterface pointer passed to Connect()");
+ DALI_ASSERT_ALWAYS(nullptr != callback && "Invalid member function pointer passed to Connect()");
- int32_t index = FindCallback( callback );
+ int32_t index = FindCallback(callback);
// Don't double-connect the same callback
- if( INVALID_CALLBACK_INDEX == index )
+ if(INVALID_CALLBACK_INDEX == index)
{
// create a new signal connection object, to allow the signal to track the connection.
- SignalConnection* connection = new SignalConnection( tracker, callback );
+ SignalConnection* connection = new SignalConnection(tracker, callback);
- mSignalConnections.PushBack( connection );
+ mSignalConnections.PushBack(connection);
// Let the connection tracker know that a connection between a signal and a slot has been made.
- tracker->SignalConnected( this, callback );
+ tracker->SignalConnected(this, callback);
}
else
{
}
}
-void BaseSignal::OnDisconnect( ConnectionTrackerInterface* tracker, CallbackBase* callback )
+void BaseSignal::OnDisconnect(ConnectionTrackerInterface* tracker, CallbackBase* callback)
{
- DALI_ASSERT_ALWAYS( NULL != tracker && "Invalid ConnectionTrackerInterface pointer passed to Disconnect()" );
- DALI_ASSERT_ALWAYS( NULL != callback && "Invalid member function pointer passed to Disconnect()" );
+ DALI_ASSERT_ALWAYS(nullptr != tracker && "Invalid ConnectionTrackerInterface pointer passed to Disconnect()");
+ DALI_ASSERT_ALWAYS(nullptr != callback && "Invalid member function pointer passed to Disconnect()");
- int32_t index = FindCallback( callback );
+ int32_t index = FindCallback(callback);
- if( index > INVALID_CALLBACK_INDEX )
+ if(index > INVALID_CALLBACK_INDEX)
{
// temporary pointer to disconnected callback
CallbackBase* disconnectedCallback = mSignalConnections[index]->GetCallback();
// close the signal side connection first.
- DeleteConnection( index );
+ DeleteConnection(index);
// close the slot side connection
- tracker->SignalDisconnected( this, disconnectedCallback );
+ tracker->SignalDisconnected(this, disconnectedCallback);
}
// call back is a temporary created to find which slot should be disconnected.
}
// for SlotObserver::SlotDisconnected
-void BaseSignal::SlotDisconnected( CallbackBase* callback )
+void BaseSignal::SlotDisconnected(CallbackBase* callback)
{
- const std::size_t count( mSignalConnections.Count() );
- for( std::size_t i=0; i < count; ++i )
+ const std::size_t count(mSignalConnections.Count());
+ for(std::size_t i = 0; i < count; ++i)
{
- const CallbackBase* connectionCallback = GetCallback( i );
+ const CallbackBase* connectionCallback = GetCallback(i);
// Pointer comparison i.e. SignalConnection contains pointer to same callback instance
- if( connectionCallback &&
- connectionCallback == callback )
+ if(connectionCallback &&
+ connectionCallback == callback)
{
- DeleteConnection( i );
+ DeleteConnection(i);
// Disconnection complete
return;
}
}
- DALI_ABORT( "Callback lost in SlotDisconnected()" );
+ DALI_ABORT("Callback lost in SlotDisconnected()");
}
-CallbackBase* BaseSignal::GetCallback( std::size_t connectionIndex ) const
+CallbackBase* BaseSignal::GetCallback(std::size_t connectionIndex) const
{
- DALI_ASSERT_ALWAYS( connectionIndex < mSignalConnections.Count() && "GetCallback called with invalid index" );
+ DALI_ASSERT_ALWAYS(connectionIndex < mSignalConnections.Count() && "GetCallback called with invalid index");
- CallbackBase* callback( NULL );
+ CallbackBase* callback(nullptr);
- SignalConnection* connection( mSignalConnections[ connectionIndex ] );
+ SignalConnection* connection(mSignalConnections[connectionIndex]);
// Note that values are set to NULL in DeleteConnection
- if( connection )
+ if(connection)
{
callback = connection->GetCallback();
}
return callback;
}
-int32_t BaseSignal::FindCallback( CallbackBase* callback )
+int32_t BaseSignal::FindCallback(CallbackBase* callback)
{
- int32_t index( INVALID_CALLBACK_INDEX );
+ int32_t index(INVALID_CALLBACK_INDEX);
// A signal can have multiple slots connected to it.
// We need to search for the slot which has the same call back function (if it's static)
// Or the same object / member function (for non-static)
const std::size_t count = mSignalConnections.Count();
- for( std::size_t i = 0; i < count; ++i )
+ for(std::size_t i = 0; i < count; ++i)
{
- const CallbackBase* connectionCallback = GetCallback( i );
+ const CallbackBase* connectionCallback = GetCallback(i);
// Note that values are set to NULL in DeleteConnection
- if( connectionCallback && ( *connectionCallback == *callback ) )
+ if(connectionCallback && (*connectionCallback == *callback))
{
- index = static_cast<int>( i ); // only 2,147,483,647 connections supported, no error check
+ index = static_cast<int>(i); // only 2,147,483,647 connections supported, no error check
break;
}
}
return index;
}
-void BaseSignal::DeleteConnection( std::size_t connectionIndex )
+void BaseSignal::DeleteConnection(std::size_t connectionIndex)
{
- DALI_ASSERT_ALWAYS( connectionIndex < mSignalConnections.Count() && "DeleteConnection called with invalid index" );
+ DALI_ASSERT_ALWAYS(connectionIndex < mSignalConnections.Count() && "DeleteConnection called with invalid index");
// delete the object
- SignalConnection* connection( mSignalConnections[ connectionIndex ] );
+ SignalConnection* connection(mSignalConnections[connectionIndex]);
delete connection;
- if( mEmittingFlag )
+ if(mEmittingFlag)
{
// IMPORTANT - do not remove from items from mSignalConnections, set to NULL instead.
// Signal Emit() methods require that connection count is not reduced while iterating
// i.e. DeleteConnection can be called from within callbacks, while iterating through mSignalConnections.
- mSignalConnections[ connectionIndex ] = NULL;
+ mSignalConnections[connectionIndex] = nullptr;
}
else
{
// If application connects and disconnects without the signal never emitting,
// the mSignalConnections vector keeps growing and growing as CleanupConnections() is done from Emit.
- mSignalConnections.Erase( mSignalConnections.Begin() + connectionIndex );
+ mSignalConnections.Erase(mSignalConnections.Begin() + connectionIndex);
}
}
{
const std::size_t total = mSignalConnections.Count();
// only do something if there are items
- if( total > 0 )
+ if(total > 0)
{
std::size_t index = 0;
// process the whole vector
- for( std::size_t i = 0; i < total; ++i )
+ for(std::size_t i = 0; i < total; ++i)
{
- if( mSignalConnections[ index ] == NULL )
+ if(mSignalConnections[index] == nullptr)
{
// items will be moved so don't increase index (erase will decrease the count of vector)
- mSignalConnections.Erase( mSignalConnections.Begin() + index );
+ mSignalConnections.Erase(mSignalConnections.Begin() + index);
}
else
{
// BaseSignal::EmitGuard
-BaseSignal::EmitGuard::EmitGuard( bool& flag )
-: mFlag( NULL )
+BaseSignal::EmitGuard::EmitGuard(bool& flag)
+: mFlag(nullptr)
{
- if( !flag )
+ if(!flag)
{
mFlag = &flag;
- flag = true;
+ flag = true;
}
else
{
// mFlag is NULL when Emit() is called during Emit()
- DALI_LOG_ERROR( "Cannot call Emit() from inside Emit()\n" );
+ DALI_LOG_ERROR("Cannot call Emit() from inside Emit()\n");
}
}
BaseSignal::EmitGuard::~EmitGuard()
{
- if( mFlag )
+ if(mFlag)
{
*mFlag = false;
}
bool BaseSignal::EmitGuard::ErrorOccurred()
{
// mFlag is NULL when Emit() is called during Emit()
- return (NULL == mFlag);
+ return (nullptr == mFlag);
}
} // namespace Dali
class DALI_CORE_API BaseSignal : public SlotObserver
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_0.0
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~BaseSignal();
+ ~BaseSignal() override;
/**
* @brief Queries whether there are any connected slots.
* @SINCE_1_0.0
* @param[in,out] flag This flag will be set to true during Emit() calls
*/
- EmitGuard( bool& flag );
+ EmitGuard(bool& flag);
/**
* @brief Non-virtual destructor.
* @return The value returned by the last callback
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Ret >
+ template<typename Ret>
Ret EmitReturn()
{
Ret returnVal = Ret();
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag );
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag);
+ if(guard.ErrorOccurred())
{
return returnVal;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- returnVal = CallbackBase::ExecuteReturn<Ret>( *callback );
+ returnVal = CallbackBase::ExecuteReturn<Ret>(*callback);
}
}
* @param[in] arg0 The first parameter
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Arg0 >
- void Emit( Arg0 arg0 )
+ template<typename Arg0>
+ void Emit(Arg0 arg0)
{
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- CallbackBase::Execute<Arg0 >( *callback, arg0 );
+ CallbackBase::Execute<Arg0>(*callback, arg0);
}
}
* @return The value returned by the last callback
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Ret, typename Arg0 >
- Ret EmitReturn( Arg0 arg0 )
+ template<typename Ret, typename Arg0>
+ Ret EmitReturn(Arg0 arg0)
{
Ret returnVal = Ret();
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return returnVal;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- returnVal = CallbackBase::ExecuteReturn<Ret,Arg0>( *callback, arg0 );
+ returnVal = CallbackBase::ExecuteReturn<Ret, Arg0>(*callback, arg0);
}
}
* @param[in] arg1 The second parameter
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Arg0, typename Arg1 >
- void Emit( Arg0 arg0, Arg1 arg1 )
+ template<typename Arg0, typename Arg1>
+ void Emit(Arg0 arg0, Arg1 arg1)
{
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- CallbackBase::Execute<Arg0,Arg1>( *callback, arg0, arg1 );
+ CallbackBase::Execute<Arg0, Arg1>(*callback, arg0, arg1);
}
}
* @return The value returned by the last callback
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Ret, typename Arg0, typename Arg1 >
- Ret EmitReturn( Arg0 arg0, Arg1 arg1 )
+ template<typename Ret, typename Arg0, typename Arg1>
+ Ret EmitReturn(Arg0 arg0, Arg1 arg1)
{
Ret returnVal = Ret();
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return returnVal;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- returnVal = CallbackBase::ExecuteReturn<Ret,Arg0,Arg1>( *callback, arg0, arg1 );
+ returnVal = CallbackBase::ExecuteReturn<Ret, Arg0, Arg1>(*callback, arg0, arg1);
}
}
* @param[in] arg2 The third parameter
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Arg0, typename Arg1, typename Arg2 >
- void Emit( Arg0 arg0, Arg1 arg1, Arg2 arg2 )
+ template<typename Arg0, typename Arg1, typename Arg2>
+ void Emit(Arg0 arg0, Arg1 arg1, Arg2 arg2)
{
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- CallbackBase::Execute<Arg0,Arg1,Arg2>( *callback, arg0, arg1, arg2 );
+ CallbackBase::Execute<Arg0, Arg1, Arg2>(*callback, arg0, arg1, arg2);
}
}
* @return The value returned by the last callback
* @pre Cannot be called from inside the same Signal's Emit methods.
*/
- template< typename Ret, typename Arg0, typename Arg1, typename Arg2 >
- Ret EmitReturn( Arg0 arg0, Arg1 arg1, Arg2 arg2 )
+ template<typename Ret, typename Arg0, typename Arg1, typename Arg2>
+ Ret EmitReturn(Arg0 arg0, Arg1 arg1, Arg2 arg2)
{
Ret returnVal = Ret();
// Guards against nested Emit() calls
- EmitGuard guard( mEmittingFlag ); // Guards against nested Emit() calls
- if( guard.ErrorOccurred() )
+ EmitGuard guard(mEmittingFlag); // Guards against nested Emit() calls
+ if(guard.ErrorOccurred())
{
return returnVal;
}
// If more connections are added by callbacks, these are ignore until the next Emit()
// Note that count cannot be reduced while iterating
- const std::size_t initialCount( mSignalConnections.Count() );
+ const std::size_t initialCount(mSignalConnections.Count());
- for( std::size_t i = 0; i < initialCount; ++i )
+ for(std::size_t i = 0; i < initialCount; ++i)
{
- CallbackBase* callback( GetCallback(i) );
+ CallbackBase* callback(GetCallback(i));
// Note that connections will be set to NULL when disconnected
// This is preferable to reducing the connection count while iterating
- if( callback )
+ if(callback)
{
- returnVal = CallbackBase::ExecuteReturn<Ret,Arg0,Arg1,Arg2>( *callback, arg0, arg1, arg2 );
+ returnVal = CallbackBase::ExecuteReturn<Ret, Arg0, Arg1, Arg2>(*callback, arg0, arg1, arg2);
}
}
* @SINCE_1_0.0
* @param[in] callback A newly allocated callback object (takes ownership)
*/
- void OnConnect( CallbackBase* callback );
+ void OnConnect(CallbackBase* callback);
/**
* @brief Called by Signal implementations, when the user calls Signal.Disconnect( ... ).
* @SINCE_1_0.0
* @param[in] callback A newly allocated callback object (takes ownership)
*/
- void OnDisconnect( CallbackBase* callback );
+ void OnDisconnect(CallbackBase* callback);
/**
* @brief Called by Signal implementations, when the user calls Signal.Connect( ... ).
* @param[in] tracker The connection tracker
* @param[in] callback A newly allocated callback object (takes ownership)
*/
- void OnConnect( ConnectionTrackerInterface* tracker, CallbackBase* callback );
+ void OnConnect(ConnectionTrackerInterface* tracker, CallbackBase* callback);
/**
* @brief Called by Signal implementations, when the user calls Signal.Disconnect( ... ).
* @param[in] tracker The connection tracker
* @param[in] callback A newly allocated callback object (takes ownership)
*/
- void OnDisconnect( ConnectionTrackerInterface* tracker, CallbackBase* callback );
+ void OnDisconnect(ConnectionTrackerInterface* tracker, CallbackBase* callback);
private: // SlotObserver interface, to be told when a slot disconnects
-
/**
* @copydoc SlotObserver::SlotDisconnected
*/
- virtual void SlotDisconnected( CallbackBase* callback );
+ void SlotDisconnected(CallbackBase* callback) override;
private:
-
/**
* @brief Returns a callback given an index in to the connection array.
*
* @param[in] connectionIndex The index of the callback
* @return The callback, or NULL if the connection has been deleted
*/
- CallbackBase* GetCallback( std::size_t connectionIndex ) const;
+ CallbackBase* GetCallback(std::size_t connectionIndex) const;
/**
* @brief Helper to find whether a callback is connected.
* @param[in] callback The call back object
* @return A valid index if the callback is connected
*/
- int32_t FindCallback( CallbackBase* callback );
+ int32_t FindCallback(CallbackBase* callback);
/**
* @brief Deletes a connection object from the list of connections.
* @SINCE_1_0.0
* @param[in] connectionIndex The index of the callback
*/
- void DeleteConnection( std::size_t connectionIndex );
+ void DeleteConnection(std::size_t connectionIndex);
/**
* @brief Helper to remove NULL items from mSignalConnections, which is only safe at the end of Emit()
*/
void CleanupConnections();
- BaseSignal( const BaseSignal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- BaseSignal( BaseSignal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- BaseSignal& operator=( const BaseSignal& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- BaseSignal& operator=( BaseSignal&& ) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
+ BaseSignal(const BaseSignal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ BaseSignal(BaseSignal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ BaseSignal& operator=(const BaseSignal&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ BaseSignal& operator=(BaseSignal&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
private:
-
- Dali::Vector< SignalConnection* > mSignalConnections; ///< Array of connections
+ Dali::Vector<SignalConnection*> mSignalConnections; ///< Array of connections
bool mEmittingFlag; ///< Used to guard against nested Emit() calls
};
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/signals/callback.h>
-
namespace Dali
{
-
// CallbackBase
CallbackBase::CallbackBase()
-: mImpl( NULL ),
- mFunction( NULL )
+: mImpl(nullptr),
+ mFunction(nullptr)
{
}
Reset();
}
-CallbackBase::CallbackBase( Function function )
-: mImpl( NULL ),
- mFunction( function )
+CallbackBase::CallbackBase(Function function)
+: mImpl(nullptr),
+ mFunction(function)
{
}
-CallbackBase::CallbackBase( void* object, MemberFunction function, Dispatcher dispatcher )
-: mMemberFunction( function )
+CallbackBase::CallbackBase(void* object, MemberFunction function, Dispatcher dispatcher)
+: mMemberFunction(function)
{
mImpl = new CallbackBase::Impl;
- if( mImpl )
+ if(mImpl)
{
- mImpl->mObjectPointer = object;
+ mImpl->mObjectPointer = object;
mImpl->mMemberFunctionDispatcher = dispatcher;
- mImpl->mDestructorDispatcher = NULL; // object is not owned
+ mImpl->mDestructorDispatcher = nullptr; // object is not owned
}
}
-CallbackBase::CallbackBase( void* object, MemberFunction function, Dispatcher dispatcher, Destructor destructor )
-: mMemberFunction( function )
+CallbackBase::CallbackBase(void* object, MemberFunction function, Dispatcher dispatcher, Destructor destructor)
+: mMemberFunction(function)
{
mImpl = new CallbackBase::Impl;
- if( mImpl )
+ if(mImpl)
{
- mImpl->mObjectPointer = object;
+ mImpl->mObjectPointer = object;
mImpl->mMemberFunctionDispatcher = dispatcher;
- mImpl->mDestructorDispatcher = destructor; // object is owned
+ mImpl->mDestructorDispatcher = destructor; // object is owned
}
}
void CallbackBase::Reset()
{
- if( mImpl )
+ if(mImpl)
{
// if destructor function is set it means we own this object
- if ( mImpl->mObjectPointer &&
- mImpl->mDestructorDispatcher )
+ if(mImpl->mObjectPointer &&
+ mImpl->mDestructorDispatcher)
{
// call the destructor dispatcher
- (*mImpl->mDestructorDispatcher)( mImpl->mObjectPointer );
+ (*mImpl->mDestructorDispatcher)(mImpl->mObjectPointer);
}
delete mImpl;
- mImpl = NULL;
+ mImpl = nullptr;
}
- mFunction = NULL;
+ mFunction = nullptr;
}
// CallbackBase::Impl
CallbackBase::Impl::Impl()
-: mObjectPointer( NULL ),
- mMemberFunctionDispatcher( NULL ),
- mDestructorDispatcher( NULL )
+: mObjectPointer(nullptr),
+ mMemberFunctionDispatcher(nullptr),
+ mDestructorDispatcher(nullptr)
{
}
// Non-member equality operator
-bool operator==( const CallbackBase& lhs, const CallbackBase& rhs )
+bool operator==(const CallbackBase& lhs, const CallbackBase& rhs)
{
- if( lhs.mImpl )
+ if(lhs.mImpl)
{
// check it's the same member function / object
- return ( lhs.mFunction == rhs.mFunction ) && ( lhs.mImpl->mObjectPointer == rhs.mImpl->mObjectPointer );
+ return (lhs.mFunction == rhs.mFunction) && (lhs.mImpl->mObjectPointer == rhs.mImpl->mObjectPointer);
}
else
{
// check if it the same C function or a static member function
- return ( lhs.mFunction == rhs.mFunction );
+ return (lhs.mFunction == rhs.mFunction);
}
}
-} // namespace DALI
+} // namespace Dali
#define DALI_CALLBACK_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 DALI_CORE_API CallbackBase
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] callback The callback to call
*/
- static void Execute( CallbackBase& callback )
+ static void Execute(CallbackBase& callback)
{
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code so the library containing
// the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
Dispatcher dispatcher = callback.mImpl->mMemberFunctionDispatcher;
- (*dispatcher)( callback );
+ (*dispatcher)(callback);
}
// its also possible to have a member function pointer to a CallbackProvider
// that has been deleted, so check if we have impl still
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
(*(callback.mFunction))();
}
else
{
- DALI_ASSERT_ALWAYS( 0 && "no function to execute" );
+ DALI_ASSERT_ALWAYS(0 && "no function to execute");
}
}
* @param[in] callback The callback to call
* @return The value from the function
*/
- template< typename R >
- static R ExecuteReturn( CallbackBase& callback )
+ template<typename R>
+ static R ExecuteReturn(CallbackBase& callback)
{
R returnVal = R();
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code so the library containing
// the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef R(*Dispatcher)(CallbackBase& base);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- returnVal = (*dispatcher)( callback );
+ using Dispatcher = R (*)(CallbackBase&);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ returnVal = (*dispatcher)(callback);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
- typedef R(*Function1)();
- returnVal = (*(reinterpret_cast< Function1 >( callback.mFunction )))();
+ using Function1 = R (*)();
+ returnVal = (*(reinterpret_cast<Function1>(callback.mFunction)))();
}
return returnVal;
* @param[in] callback The callback to call
* @param[in] param1 The first parameter to pass into the function
*/
- template< typename P1 >
- static void Execute( CallbackBase& callback, P1 param1 )
+ template<typename P1>
+ static void Execute(CallbackBase& callback, P1 param1)
{
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code (where the callback was created)
// so the library containing the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef void(*Dispatcher)(CallbackBase& base,P1);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- (*dispatcher)( callback, param1 );
+ using Dispatcher = void (*)(CallbackBase&, P1);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ (*dispatcher)(callback, param1);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
// convert function type
- typedef void(*Function1)(P1);
- (*(reinterpret_cast< Function1 >( callback.mFunction )))( param1 );
+ using Function1 = void (*)(P1);
+ (*(reinterpret_cast<Function1>(callback.mFunction)))(param1);
}
}
* @param[in] param1 The first parameter to pass into the function
* @return The value from the function
*/
- template< typename R, typename P1 >
- static R ExecuteReturn( CallbackBase& callback, P1 param1 )
+ template<typename R, typename P1>
+ static R ExecuteReturn(CallbackBase& callback, P1 param1)
{
- R returnVal = R();
+ R returnVal = R();
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code (where the callback was created)
// so the library containing the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef R(*Dispatcher)(CallbackBase& base,P1);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- returnVal = (*dispatcher)( callback, param1 );
+ using Dispatcher = R (*)(CallbackBase&, P1);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ returnVal = (*dispatcher)(callback, param1);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
// convert function type
- typedef R(*Function1)(P1);
- returnVal = (*(reinterpret_cast< Function1 >( callback.mFunction )))( param1 );
+ using Function1 = R (*)(P1);
+ returnVal = (*(reinterpret_cast<Function1>(callback.mFunction)))(param1);
}
return returnVal;
* @param[in] param1 The first parameter to pass into the function
* @param[in] param2 The second parameter to pass into the function
*/
- template< typename P1, typename P2 >
- static void Execute( CallbackBase& callback, P1 param1, P2 param2 )
+ template<typename P1, typename P2>
+ static void Execute(CallbackBase& callback, P1 param1, P2 param2)
{
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code (where the callback was created)
// so the library containing the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef void(*Dispatcher)(CallbackBase& base,P1,P2);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- (*dispatcher)( callback, param1, param2 );
+ using Dispatcher = void (*)(CallbackBase&, P1, P2);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ (*dispatcher)(callback, param1, param2);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
// convert function type
- typedef void(*Function2)(P1,P2);
- (*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2 );
+ using Function2 = void (*)(P1, P2);
+ (*(reinterpret_cast<Function2>(callback.mFunction)))(param1, param2);
}
}
* @param[in] param2 The second parameter to pass into the function
* @return The return value from the function
*/
- template< typename R, typename P1, typename P2 >
- static R ExecuteReturn( CallbackBase& callback, P1 param1, P2 param2 )
+ template<typename R, typename P1, typename P2>
+ static R ExecuteReturn(CallbackBase& callback, P1 param1, P2 param2)
{
- R returnVal= R();
+ R returnVal = R();
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code (where the callback was created)
// so the library containing the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef R(*Dispatcher)(CallbackBase& base,P1,P2);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- returnVal = (*dispatcher)( callback, param1, param2 );
+ using Dispatcher = R (*)(CallbackBase&, P1, P2);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ returnVal = (*dispatcher)(callback, param1, param2);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
// convert function type
- typedef R(*Function2)(P1,P2);
- returnVal = (*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2 );
+ using Function2 = R (*)(P1, P2);
+ returnVal = (*(reinterpret_cast<Function2>(callback.mFunction)))(param1, param2);
}
return returnVal;
* @param[in] param2 The second parameter to pass into the function
* @param[in] param3 The third parameter to pass into the function
*/
- template< typename P1, typename P2, typename P3 >
- static void Execute( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ template<typename P1, typename P2, typename P3>
+ static void Execute(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code (where the callback was created)
// so the library containing the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef void(*Dispatcher)(CallbackBase& base,P1,P2,P3);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- (*dispatcher)( callback, param1, param2, param3 );
+ using Dispatcher = void (*)(CallbackBase&, P1, P2, P3);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ (*dispatcher)(callback, param1, param2, param3);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
// convert function type
- typedef void(*Function2)(P1,P2,P3);
- (*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2, param3 );
+ using Function2 = void (*)(P1, P2, P3);
+ (*(reinterpret_cast<Function2>(callback.mFunction)))(param1, param2, param3);
}
}
* @param[in] param3 The third parameter to pass into the function
* @return The return value from the function
*/
- template< typename R, typename P1, typename P2, typename P3 >
- static R ExecuteReturn( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ template<typename R, typename P1, typename P2, typename P3>
+ static R ExecuteReturn(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
- R returnVal= R();
+ R returnVal = R();
// if we point to a function, we can call it directly
// otherwise call the dispatcher function that knows the real type of the object
// Note that this template dispatcher lives in client code (where the callback was created)
// so the library containing the code has to be loaded, otherwise we crash boom bang
- if( callback.mImpl && callback.mImpl->mObjectPointer )
+ if(callback.mImpl && callback.mImpl->mObjectPointer)
{
- typedef R(*Dispatcher)(CallbackBase& base,P1,P2,P3);
- Dispatcher dispatcher = reinterpret_cast< Dispatcher >( callback.mImpl->mMemberFunctionDispatcher );
- returnVal = (*dispatcher)( callback, param1, param2, param3 );
+ using Dispatcher = R (*)(CallbackBase&, P1, P2, P3);
+ Dispatcher dispatcher = reinterpret_cast<Dispatcher>(callback.mImpl->mMemberFunctionDispatcher);
+ returnVal = (*dispatcher)(callback, param1, param2, param3);
}
- else if( !callback.mImpl && callback.mFunction )
+ else if(!callback.mImpl && callback.mFunction)
{
// convert function type
- typedef R(*Function2)(P1,P2,P3);
- returnVal = (*(reinterpret_cast< Function2 >( callback.mFunction )))( param1, param2, param3 );
+ using Function2 = R (*)(P1, P2, P3);
+ returnVal = (*(reinterpret_cast<Function2>(callback.mFunction)))(param1, param2, param3);
}
return returnVal;
}
protected: // Constructors for deriving classes
-
/**
* @brief Function with static linkage.
* @SINCE_1_0.0
*/
- typedef void(*Function)(void);
+ using Function = void (*)();
/**
* @brief Member function.
* @SINCE_1_0.0
*/
- typedef void (CallbackBase::*MemberFunction)( void );
+ using MemberFunction = void (CallbackBase::*)();
/**
* @brief Used to call the correct member function.
* @SINCE_1_0.0
*/
- typedef void (*Dispatcher)( CallbackBase& base );
+ using Dispatcher = void (*)(CallbackBase&);
/**
* @brief Used to destroy mObjectPointer (NULL if not mObjectPointer is not owned).
* @SINCE_1_0.0
*/
- typedef void(*Destructor)(void* object);
+ using Destructor = void (*)(void*);
/**
* @brief Copy constructor operator not declared.
* @SINCE_1_0.0
* @param[in] rhs Handle to an object
*/
- CallbackBase( const CallbackBase& rhs );
+ CallbackBase(const CallbackBase& rhs);
/**
* @brief Assignment operator not declared.
* @param[in] rhs Handle to an object
* @return A reference to this
*/
- CallbackBase& operator=( const CallbackBase& rhs );
+ CallbackBase& operator=(const CallbackBase& rhs);
/**
* @brief Constructor for function with static linkage.
* @SINCE_1_0.0
* @param[in] function The function to call
*/
- CallbackBase( Function function );
+ CallbackBase(Function function);
/**
* @brief Constructor for member function.
* @param[in] function The member function of the object
* @param[in] dispatcher Used to call the actual object
*/
- CallbackBase( void* object, MemberFunction function, Dispatcher dispatcher );
+ CallbackBase(void* object, MemberFunction function, Dispatcher dispatcher);
/**
* @brief Constructor for member function.
* @param dispatcher Used to call the actual object
* @param destructor Used to delete the owned object
*/
- CallbackBase( void* object, MemberFunction function, Dispatcher dispatcher, Destructor destructor );
+ CallbackBase(void* object, MemberFunction function, Dispatcher dispatcher, Destructor destructor);
public: // Data for deriving classes & Dispatchers
-
/**
* @brief Struct to hold the extra data needed for member functions.
* @SINCE_1_0.0
*/
struct Impl
{
- Impl(); ///< Default constructor @SINCE_1_0.0
+ Impl(); ///< Default constructor @SINCE_1_0.0
- void* mObjectPointer; ///< Object whose member function will be called. Not owned if mDestructorDispatcher is NULL.
+ void* mObjectPointer; ///< Object whose member function will be called. Not owned if mDestructorDispatcher is NULL.
Dispatcher mMemberFunctionDispatcher; ///< Dispatcher for member functions
Destructor mDestructorDispatcher; ///< Destructor for owned objects. NULL if mDestructorDispatcher is not owned.
};
- Impl* mImpl; ///< Implementation pointer
+ Impl* mImpl; ///< Implementation pointer
union
{
- MemberFunction mMemberFunction; ///< Pointer to member function
- Function mFunction; ///< Static function
+ MemberFunction mMemberFunction; ///< Pointer to member function
+ Function mFunction; ///< Static function
};
};
* @param[in] rhs A reference to compare to
* @return True if lhs is same as rhs
*/
-bool operator==( const CallbackBase& lhs, const CallbackBase& rhs );
+bool operator==(const CallbackBase& lhs, const CallbackBase& rhs);
/**
* @brief Dispatcher to delete an object.
* @SINCE_1_0.0
*/
-template< class T >
+template<class T>
struct Destroyer
{
/**
* @SINCE_1_0.0
* @param[in] object An object to delete
*/
- static void Delete( void* object )
+ static void Delete(void* object)
{
// CallbackBase owns the object but we're the only one who knows the real type so need
// to delete by "downcasting" from void* to the correct type
- delete reinterpret_cast< T* >( object );
+ delete reinterpret_cast<T*>(object);
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T >
+template<class T>
struct Dispatcher0
{
/**
* @SINCE_1_0.0
* @param[in] callback The callback information
*/
- static void Dispatch( CallbackBase& callback )
+ static void Dispatch(CallbackBase& callback)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)();
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename P1 >
+template<class T, typename P1>
struct Dispatcher1
{
/**
* @param[in] callback The callback information
* @param[in] param1 The first parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1 )
+ static void Dispatch(CallbackBase& callback, P1 param1)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(P1);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
- (object->*function)( param1 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)(P1);
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
+ (object->*function)(param1);
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2 >
+template<class T, typename P1, typename P2>
struct Dispatcher2
{
/**
* @param[in] param1 The first parameter to pass to the real member function
* @param[in] param2 The second parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1, P2 param2 )
+ static void Dispatch(CallbackBase& callback, P1 param1, P2 param2)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(P1, P2);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
- (object->*function)( param1, param2 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)(P1, P2);
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
+ (object->*function)(param1, param2);
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2, typename P3 >
+template<class T, typename P1, typename P2, typename P3>
struct Dispatcher3
{
/**
* @param[in] param2 The second parameter to pass to the real member function
* @param[in] param3 The third parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ static void Dispatch(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(P1, P2, P3);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
- (object->*function)( param1, param2, param3 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)(P1, P2, P3);
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
+ (object->*function)(param1, param2, param3);
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename R >
+template<class T, typename R>
struct DispatcherReturn0
{
/**
* @param[in] callback The callback information
* @return The value
*/
- static R Dispatch( CallbackBase& callback )
+ static R Dispatch(CallbackBase& callback)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = R (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
return (object->*function)();
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1 >
+template<class T, typename R, typename P1>
struct DispatcherReturn1
{
/**
* @param[in] param1 The first parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1 )
+ static R Dispatch(CallbackBase& callback, P1 param1)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(P1);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
- return (object->*function)( param1 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = R (T::*)(P1);
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
+ return (object->*function)(param1);
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1, typename P2 >
+template<class T, typename R, typename P1, typename P2>
struct DispatcherReturn2
{
/**
* @param[in] param2 The second parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1, P2 param2 )
+ static R Dispatch(CallbackBase& callback, P1 param1, P2 param2)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(P1, P2);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
- return (object->*function)( param1, param2 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = R (T::*)(P1, P2);
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
+ return (object->*function)(param1, param2);
}
};
* @brief Dispatcher to call the actual member function.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1, typename P2, typename P3 >
+template<class T, typename R, typename P1, typename P2, typename P3>
struct DispatcherReturn3
{
/**
* @param[in] param3 The third parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ static R Dispatch(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef R(T::*MemberFunction)(P1, P2, P3);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
- return (object->*function)( param1, param2, param3 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = R (T::*)(P1, P2, P3);
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
+ return (object->*function)(param1, param2, param3);
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T >
+template<class T>
struct FunctorDispatcher0
{
/**
* @SINCE_1_0.0
* @param[in] callback The callback information
*/
- static void Dispatch( CallbackBase& callback )
+ static void Dispatch(CallbackBase& callback)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
(*object)();
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename P1 >
+template<class T, typename P1>
struct FunctorDispatcher1
{
/**
* @param[in] callback The callback information
* @param[in] param1 The first parameter to pass to the real member function.
*/
- static void Dispatch( CallbackBase& callback, P1 param1 )
+ static void Dispatch(CallbackBase& callback, P1 param1)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- (*object)( param1 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ (*object)(param1);
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2 >
+template<class T, typename P1, typename P2>
struct FunctorDispatcher2
{
/**
* @param[in] param1 The first parameter to pass to the real member function
* @param[in] param2 The second parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1, P2 param2 )
+ static void Dispatch(CallbackBase& callback, P1 param1, P2 param2)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- (*object)( param1, param2 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ (*object)(param1, param2);
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2, typename P3 >
+template<class T, typename P1, typename P2, typename P3>
struct FunctorDispatcher3
{
/**
* @param[in] param2 The second parameter to pass to the real member function
* @param[in] param3 The third parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ static void Dispatch(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- (*object)( param1, param2, param3 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ (*object)(param1, param2, param3);
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename R >
+template<class T, typename R>
struct FunctorDispatcherReturn0
{
/**
* @param[in] callback The callback information
* @return The value
*/
- static R Dispatch( CallbackBase& callback )
+ static R Dispatch(CallbackBase& callback)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
return (*object)();
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1 >
+template<class T, typename R, typename P1>
struct FunctorDispatcherReturn1
{
/**
* @param[in] param1 The first parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1 )
+ static R Dispatch(CallbackBase& callback, P1 param1)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- return (*object)( param1 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ return (*object)(param1);
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1, typename P2 >
+template<class T, typename R, typename P1, typename P2>
struct FunctorDispatcherReturn2
{
/**
* @param[in] param2 The second parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1, P2 param2 )
+ static R Dispatch(CallbackBase& callback, P1 param1, P2 param2)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- return (*object)( param1, param2 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ return (*object)(param1, param2);
}
};
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1, typename P2, typename P3 >
+template<class T, typename R, typename P1, typename P2, typename P3>
struct FunctorDispatcherReturn3
{
/**
* @param[in] param3 The third parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ static R Dispatch(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- return (*object)( param1, param2, param3 );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ return (*object)(param1, param2, param3);
}
};
* This variant calls a specific void() member function.
* @SINCE_1_0.0
*/
-template< class T >
+template<class T>
struct VoidFunctorDispatcher0
{
/**
* @SINCE_1_0.0
* @param[in] callback The callback information
*/
- static void Dispatch( CallbackBase& callback )
+ static void Dispatch(CallbackBase& callback)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)();
}
};
* This variant calls a void() member, ignoring any signal parameters.
* @SINCE_1_0.0
*/
-template< class T, typename P1 >
+template<class T, typename P1>
struct VoidFunctorDispatcher1
{
/**
* @param[in] callback The callback information
* @param[in] param1 The first parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1 )
+ static void Dispatch(CallbackBase& callback, P1 param1)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
}
};
* This variant calls a void() member, ignoring any signal parameters.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2 >
+template<class T, typename P1, typename P2>
struct VoidFunctorDispatcher2
{
/**
* @param[in] param1 The first parameter to pass to the real member function
* @param[in] param2 The second parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1, P2 param2 )
+ static void Dispatch(CallbackBase& callback, P1 param1, P2 param2)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
}
};
* This variant calls a void() member, ignoring any signal parameters.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2, typename P3 >
+template<class T, typename P1, typename P2, typename P3>
struct VoidFunctorDispatcher3
{
/**
* @param[in] param2 The second parameter to pass to the real member function
* @param[in] param3 The third parameter to pass to the real member function
*/
- static void Dispatch( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ static void Dispatch(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
}
};
* This variant calls a void() member, and returns a default-constructed value.
* @SINCE_1_0.0
*/
-template< class T, typename R >
+template<class T, typename R>
struct VoidFunctorDispatcherReturn0
{
/**
* @param[in] callback The callback information
* @return The value
*/
- static R Dispatch( CallbackBase& callback )
+ static R Dispatch(CallbackBase& callback)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
return R();
}
* This variant calls a void() member, and returns a default-constructed value.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1 >
+template<class T, typename R, typename P1>
struct VoidFunctorDispatcherReturn1
{
/**
* @param[in] param1 The first parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1 )
+ static R Dispatch(CallbackBase& callback, P1 param1)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
return R();
}
* This variant calls a void() member, and returns a default-constructed value.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1, typename P2 >
+template<class T, typename R, typename P1, typename P2>
struct VoidFunctorDispatcherReturn2
{
/**
* @param[in] param2 The second parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1, P2 param2 )
+ static R Dispatch(CallbackBase& callback, P1 param1, P2 param2)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
return R();
}
* This variant calls a void() member, and returns a default-constructed value.
* @SINCE_1_0.0
*/
-template< class T, typename R, typename P1, typename P2, typename P3 >
+template<class T, typename R, typename P1, typename P2, typename P3>
struct VoidFunctorDispatcherReturn3
{
/**
* @param[in] param3 The third parameter to pass to the real member function
* @return The return value from the function
*/
- static R Dispatch( CallbackBase& callback, P1 param1, P2 param2, P3 param3 )
+ static R Dispatch(CallbackBase& callback, P1 param1, P2 param2, P3 param3)
{
// "downcast" the object and function type back to the correct ones
- T* object = reinterpret_cast< T* >( callback.mImpl->mObjectPointer );
- typedef void(T::*MemberFunction)(void);
- MemberFunction function = reinterpret_cast< MemberFunction >( callback.mMemberFunction );
+ T* object = reinterpret_cast<T*>(callback.mImpl->mObjectPointer);
+ using MemberFunction = void (T::*)();
+ MemberFunction function = reinterpret_cast<MemberFunction>(callback.mMemberFunction);
(object->*function)(/*ignore params*/);
return R();
}
* Version with two parameters and return value.
* @SINCE_1_0.0
*/
-template< class T >
+template<class T>
class Callback : public CallbackBase
{
public:
-
/**
* @brief Default constructor.
*
* @param[in] object The object to call
* @param[in] memberFunction The member function of the object
*/
- Callback( T* object, void(T::*memberFunction)(void) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &Dispatcher0<T>::Dispatch ) ) { }
- template< typename P1 >
- Callback( T* object, void(T::*memberFunction)(P1) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &Dispatcher1<T,P1>::Dispatch ) ) { }
- template< typename P1, typename P2 >
- Callback( T* object, void(T::*memberFunction)(P1, P2) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &Dispatcher2<T,P1,P2>::Dispatch ) ) { }
- template< typename P1, typename P2, typename P3 >
- Callback( T* object, void(T::*memberFunction)(P1, P2, P3) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &Dispatcher3<T,P1,P2,P3>::Dispatch ) ) { }
- template< typename R >
- Callback( T* object, R(T::*memberFunction)(void) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &DispatcherReturn0<T,R>::Dispatch ) ) { }
- template< typename R, typename P1 >
- Callback( T* object, R(T::*memberFunction)(P1) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &DispatcherReturn1<T,R,P1>::Dispatch ) ) { }
- template< typename R, typename P1, typename P2 >
- Callback( T* object, R(T::*memberFunction)(P1, P2) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &DispatcherReturn2<T,R,P1,P2>::Dispatch ) ) { }
- template< typename R, typename P1, typename P2, typename P3 >
- Callback( T* object, R(T::*memberFunction)(P1, P2, P3) )
- : CallbackBase( object,
- reinterpret_cast< CallbackBase::MemberFunction >( memberFunction ),
- reinterpret_cast< CallbackBase::Dispatcher >( &DispatcherReturn3<T,R,P1,P2,P3>::Dispatch ) ) { }
-
+ Callback(T* object, void (T::*memberFunction)(void))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&Dispatcher0<T>::Dispatch))
+ {
+ }
+ template<typename P1>
+ Callback(T* object, void (T::*memberFunction)(P1))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&Dispatcher1<T, P1>::Dispatch))
+ {
+ }
+ template<typename P1, typename P2>
+ Callback(T* object, void (T::*memberFunction)(P1, P2))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&Dispatcher2<T, P1, P2>::Dispatch))
+ {
+ }
+ template<typename P1, typename P2, typename P3>
+ Callback(T* object, void (T::*memberFunction)(P1, P2, P3))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&Dispatcher3<T, P1, P2, P3>::Dispatch))
+ {
+ }
+ template<typename R>
+ Callback(T* object, R (T::*memberFunction)(void))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&DispatcherReturn0<T, R>::Dispatch))
+ {
+ }
+ template<typename R, typename P1>
+ Callback(T* object, R (T::*memberFunction)(P1))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&DispatcherReturn1<T, R, P1>::Dispatch))
+ {
+ }
+ template<typename R, typename P1, typename P2>
+ Callback(T* object, R (T::*memberFunction)(P1, P2))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&DispatcherReturn2<T, R, P1, P2>::Dispatch))
+ {
+ }
+ template<typename R, typename P1, typename P2, typename P3>
+ Callback(T* object, R (T::*memberFunction)(P1, P2, P3))
+ : CallbackBase(object,
+ reinterpret_cast<CallbackBase::MemberFunction>(memberFunction),
+ reinterpret_cast<CallbackBase::Dispatcher>(&DispatcherReturn3<T, R, P1, P2, P3>::Dispatch))
+ {
+ }
};
/**
class CallbackFunction : public CallbackBase
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] function The function to call
*/
- CallbackFunction( void(*function)() )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename R >
- CallbackFunction( R(*function)() )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename P1 >
- CallbackFunction( void(*function)(P1) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename P1, typename R >
- CallbackFunction( R(*function)(P1) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename P1, typename P2 >
- CallbackFunction( void(*function)(P1,P2) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename P1, typename P2, typename R >
- CallbackFunction( R(*function)(P1,P2) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename P1, typename P2, typename P3 >
- CallbackFunction( void(*function)(P1,P2,P3) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
- template< typename P1, typename P2, typename P3, typename R >
- CallbackFunction( R(*function)(P1,P2,P3) )
- : CallbackBase( reinterpret_cast< CallbackBase::Function >( function ) )
- { }
-
+ CallbackFunction(void (*function)())
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename R>
+ CallbackFunction(R (*function)())
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename P1>
+ CallbackFunction(void (*function)(P1))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename P1, typename R>
+ CallbackFunction(R (*function)(P1))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename P1, typename P2>
+ CallbackFunction(void (*function)(P1, P2))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename P1, typename P2, typename R>
+ CallbackFunction(R (*function)(P1, P2))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename P1, typename P2, typename P3>
+ CallbackFunction(void (*function)(P1, P2, P3))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
+ template<typename P1, typename P2, typename P3, typename R>
+ CallbackFunction(R (*function)(P1, P2, P3))
+ : CallbackBase(reinterpret_cast<CallbackBase::Function>(function))
+ {
+ }
};
/**
* @brief Specializations for function object callbacks.
* @SINCE_1_0.0
*/
-template< class T >
+template<class T>
class CallbackFunctor0 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctor0( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcher0<T>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctor0(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcher0<T>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
class CallbackFunctorDelegate0 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object A newly allocated object (ownership is transferred)
*/
- CallbackFunctorDelegate0( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcher0<FunctorDelegate>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegate0(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcher0<FunctorDelegate>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename P1 >
+template<class T, typename P1>
class CallbackFunctor1 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctor1( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcher1<T,P1>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctor1(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcher1<T, P1>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename P1 >
+template<typename P1>
class CallbackFunctorDelegate1 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegate1( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcher1<FunctorDelegate,P1>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegate1(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcher1<FunctorDelegate, P1>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2 >
+template<class T, typename P1, typename P2>
class CallbackFunctor2 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctor2( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcher2<T,P1,P2>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctor2(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcher2<T, P1, P2>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename P1, typename P2 >
+template<typename P1, typename P2>
class CallbackFunctorDelegate2 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegate2( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcher2<FunctorDelegate,P1,P2>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegate2(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcher2<FunctorDelegate, P1, P2>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2, typename P3 >
+template<class T, typename P1, typename P2, typename P3>
class CallbackFunctor3 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctor3( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcher3<T,P1,P2,P3>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctor3(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcher3<T, P1, P2, P3>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename P1, typename P2, typename P3 >
+template<typename P1, typename P2, typename P3>
class CallbackFunctorDelegate3 : public CallbackBase
{
public:
-
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegate3( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcher3<FunctorDelegate,P1,P2,P3>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegate3(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcher3<FunctorDelegate, P1, P2, P3>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename R >
+template<class T, typename R>
class CallbackFunctorReturn0 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorReturn0( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcherReturn0<T,R>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctorReturn0(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcherReturn0<T, R>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename R >
+template<typename R>
class CallbackFunctorDelegateReturn0 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegateReturn0( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcherReturn0<FunctorDelegate,R>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegateReturn0(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcherReturn0<FunctorDelegate, R>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename R >
+template<class T, typename P1, typename R>
class CallbackFunctorReturn1 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorReturn1( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcherReturn1<T,R,P1>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctorReturn1(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcherReturn1<T, R, P1>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename P1, typename R >
+template<typename P1, typename R>
class CallbackFunctorDelegateReturn1 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegateReturn1( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcherReturn1<FunctorDelegate,R,P1>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegateReturn1(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcherReturn1<FunctorDelegate, R, P1>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2, typename R >
+template<class T, typename P1, typename P2, typename R>
class CallbackFunctorReturn2 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorReturn2( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcherReturn2<T,R,P1,P2>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctorReturn2(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcherReturn2<T, R, P1, P2>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename P1, typename P2, typename R >
+template<typename P1, typename P2, typename R>
class CallbackFunctorDelegateReturn2 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegateReturn2( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcherReturn2<FunctorDelegate,R,P1,P2>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegateReturn2(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcherReturn2<FunctorDelegate, R, P1, P2>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for matching callbacks to signal signature.
* @SINCE_1_0.0
*/
-template< class T, typename P1, typename P2, typename P3, typename R >
+template<class T, typename P1, typename P2, typename P3, typename R>
class CallbackFunctorReturn3 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorReturn3( const T& object )
- : CallbackBase( reinterpret_cast< void* >( new T( object ) ), // copy the object
- NULL, // uses operator() instead of member function
- reinterpret_cast< CallbackBase::Dispatcher >( &FunctorDispatcherReturn3<T,R,P1,P2,P3>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<T>::Delete ) ) { }
+ CallbackFunctorReturn3(const T& object)
+ : CallbackBase(reinterpret_cast<void*>(new T(object)), // copy the object
+ NULL, // uses operator() instead of member function
+ reinterpret_cast<CallbackBase::Dispatcher>(&FunctorDispatcherReturn3<T, R, P1, P2, P3>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<T>::Delete))
+ {
+ }
};
/**
* @brief Function object callback for connecting void() methods.
* @SINCE_1_0.0
*/
-template< typename P1, typename P2, typename P3, typename R >
+template<typename P1, typename P2, typename P3, typename R>
class CallbackFunctorDelegateReturn3 : public CallbackBase
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @SINCE_1_0.0
* @param[in] object The object to copy
*/
- CallbackFunctorDelegateReturn3( FunctorDelegate* object )
- : CallbackBase( reinterpret_cast< void* >( object ), // transfer ownership
- reinterpret_cast< CallbackBase::MemberFunction >( &FunctorDelegate::Execute ),
- reinterpret_cast< CallbackBase::Dispatcher >( &VoidFunctorDispatcherReturn3<FunctorDelegate,R,P1,P2,P3>::Dispatch ),
- reinterpret_cast< CallbackBase::Destructor >( &Destroyer<FunctorDelegate>::Delete ) ) { }
+ CallbackFunctorDelegateReturn3(FunctorDelegate* object)
+ : CallbackBase(reinterpret_cast<void*>(object), // transfer ownership
+ reinterpret_cast<CallbackBase::MemberFunction>(&FunctorDelegate::Execute),
+ reinterpret_cast<CallbackBase::Dispatcher>(&VoidFunctorDispatcherReturn3<FunctorDelegate, R, P1, P2, P3>::Dispatch),
+ reinterpret_cast<CallbackBase::Destructor>(&Destroyer<FunctorDelegate>::Delete))
+ {
+ }
};
// Callback creation thin templates
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-inline CallbackBase* MakeCallback( void(*function)(void) )
+inline CallbackBase* MakeCallback(void (*function)(void))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename P1 >
-inline CallbackBase* MakeCallback( void(*function)(P1) )
+template<typename P1>
+inline CallbackBase* MakeCallback(void (*function)(P1))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename R >
-inline CallbackBase* MakeCallback( R(*function)(void) )
+template<typename R>
+inline CallbackBase* MakeCallback(R (*function)(void))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename R, typename P1 >
-inline CallbackBase* MakeCallback( R(*function)(P1) )
+template<typename R, typename P1>
+inline CallbackBase* MakeCallback(R (*function)(P1))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename P1, typename P2 >
-inline CallbackBase* MakeCallback( void(*function)(P1,P2) )
+template<typename P1, typename P2>
+inline CallbackBase* MakeCallback(void (*function)(P1, P2))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename R, typename P1, typename P2 >
-inline CallbackBase* MakeCallback( R(*function)(P1,P2) )
+template<typename R, typename P1, typename P2>
+inline CallbackBase* MakeCallback(R (*function)(P1, P2))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename P1, typename P2, typename P3 >
-inline CallbackBase* MakeCallback( void(*function)(P1,P2,P3) )
+template<typename P1, typename P2, typename P3>
+inline CallbackBase* MakeCallback(void (*function)(P1, P2, P3))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< typename R, typename P1, typename P2, typename P3 >
-inline CallbackBase* MakeCallback( R(*function)(P1,P2,P3) )
+template<typename R, typename P1, typename P2, typename P3>
+inline CallbackBase* MakeCallback(R (*function)(P1, P2, P3))
{
- return new CallbackFunction( function );
+ return new CallbackFunction(function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T >
-inline CallbackBase* MakeCallback( T* object, void(T::*function)(void) )
+template<class T>
+inline CallbackBase* MakeCallback(T* object, void (T::*function)(void))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename P1 >
-inline CallbackBase* MakeCallback( T* object, void(T::*function)(P1) )
+template<class T, typename P1>
+inline CallbackBase* MakeCallback(T* object, void (T::*function)(P1))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename P1, typename P2 >
-inline CallbackBase* MakeCallback( T* object, void(T::*function)(P1,P2) )
+template<class T, typename P1, typename P2>
+inline CallbackBase* MakeCallback(T* object, void (T::*function)(P1, P2))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename P1, typename P2, typename P3 >
-inline CallbackBase* MakeCallback( T* object, void(T::*function)(P1,P2,P3) )
+template<class T, typename P1, typename P2, typename P3>
+inline CallbackBase* MakeCallback(T* object, void (T::*function)(P1, P2, P3))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename R >
-inline CallbackBase* MakeCallback( T* object, R(T::*function)() )
+template<class T, typename R>
+inline CallbackBase* MakeCallback(T* object, R (T::*function)())
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename P1, typename R >
-inline CallbackBase* MakeCallback( T* object, R(T::*function)(P1) )
+template<class T, typename P1, typename R>
+inline CallbackBase* MakeCallback(T* object, R (T::*function)(P1))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename P1, typename P2, typename R >
-inline CallbackBase* MakeCallback( T* object, R(T::*function)(P1,P2) )
+template<class T, typename P1, typename P2, typename R>
+inline CallbackBase* MakeCallback(T* object, R (T::*function)(P1, P2))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, typename P1, typename P2, typename P3, typename R >
-inline CallbackBase* MakeCallback( T* object, R(T::*function)(P1,P2,P3) )
+template<class T, typename P1, typename P2, typename P3, typename R>
+inline CallbackBase* MakeCallback(T* object, R (T::*function)(P1, P2, P3))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, class Base >
-inline CallbackBase* MakeCallback( T* object, void(Base::*function)(void) )
+template<class T, class Base>
+inline CallbackBase* MakeCallback(T* object, void (Base::*function)(void))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @brief Creates a callback from a class's parent member function with no parameters.
* @param[in] function The member function to call
* @return A newly allocated Callback object, ownership transferred to caller
*/
-template< class T, class Base >
-inline CallbackBase* MakeCallback( T& object, void(Base::*function)(void) )
+template<class T, class Base>
+inline CallbackBase* MakeCallback(T& object, void (Base::*function)(void))
{
- return new Callback< T >( object, function );
+ return new Callback<T>(object, function);
}
/**
* @}
*/
-} // namespace DALI
+} // namespace Dali
#endif // DALI_CALLBACK_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
ConnectionTrackerInterface::ConnectionTrackerInterface()
{
}
class DALI_CORE_API ConnectionTrackerInterface : public SignalObserver
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_0.0
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~ConnectionTrackerInterface();
+ ~ConnectionTrackerInterface() override;
/**
* @brief Called when a signal is connected.
* @param[in] slotObserver The slot observer i.e. a signal. Ownership is not passed
* @param[in] callback The call back. Ownership is not passed
*/
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback ) = 0;
+ virtual void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback) = 0;
private:
-
- ConnectionTrackerInterface( const ConnectionTrackerInterface& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- ConnectionTrackerInterface( ConnectionTrackerInterface&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- ConnectionTrackerInterface& operator=( const ConnectionTrackerInterface& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- ConnectionTrackerInterface& operator=( ConnectionTrackerInterface&& ) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
+ ConnectionTrackerInterface(const ConnectionTrackerInterface&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ ConnectionTrackerInterface(ConnectionTrackerInterface&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ ConnectionTrackerInterface& operator=(const ConnectionTrackerInterface&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ ConnectionTrackerInterface& operator=(ConnectionTrackerInterface&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
};
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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/public-api/signals/connection-tracker.h>
#include <dali/public-api/signals/callback.h>
-#include <dali/public-api/signals/signal-slot-observers.h>
#include <dali/public-api/signals/signal-slot-connections.h>
+#include <dali/public-api/signals/signal-slot-observers.h>
namespace Dali
{
-
ConnectionTracker::ConnectionTracker()
{
}
{
std::size_t size = mConnections.Size();
- for( std::size_t i = 0; i< size; ++i )
+ for(std::size_t i = 0; i < size; ++i)
{
SlotConnection* connection = mConnections[i];
// Tell the signal that the slot is disconnected
- connection->GetSlotObserver()->SlotDisconnected( connection->GetCallback() );
+ connection->GetSlotObserver()->SlotDisconnected(connection->GetCallback());
delete connection;
}
mConnections.Clear();
}
-void ConnectionTracker::SignalConnected( SlotObserver* slotObserver, CallbackBase* callback )
+void ConnectionTracker::SignalConnected(SlotObserver* slotObserver, CallbackBase* callback)
{
- SlotConnection* connection = new SlotConnection( slotObserver, callback );
- mConnections.PushBack( connection );
+ SlotConnection* connection = new SlotConnection(slotObserver, callback);
+ mConnections.PushBack(connection);
}
-void ConnectionTracker::SignalDisconnected( SlotObserver* signal, CallbackBase* callback )
+void ConnectionTracker::SignalDisconnected(SlotObserver* signal, CallbackBase* callback)
{
std::size_t size = mConnections.Size();
- for( std::size_t i = 0; i< size; ++i )
+ for(std::size_t i = 0; i < size; ++i)
{
SlotConnection* connection = mConnections[i];
// Pointer comparison i.e. SignalConnection contains pointer to same callback instance
- if( connection->GetCallback() == callback )
+ if(connection->GetCallback() == callback)
{
// Remove from connection list
- mConnections.Erase( mConnections.Begin() + i );
+ mConnections.Erase(mConnections.Begin() + i);
// Delete connection
delete connection;
}
}
- DALI_ABORT( "Callback lost in SignalDisconnected()" );
+ DALI_ABORT("Callback lost in SignalDisconnected()");
}
std::size_t ConnectionTracker::GetConnectionCount() const
class DALI_CORE_API ConnectionTracker : public ConnectionTrackerInterface
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_0.0
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~ConnectionTracker();
+ ~ConnectionTracker() override;
/**
* @brief Disconnects all signals from this object.
/**
* @copydoc ConnectionTrackerInterface::SignalConnected
*/
- virtual void SignalConnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalConnected(SlotObserver* slotObserver, CallbackBase* callback) override;
/**
* @copydoc ConnectionTrackerInterface::SignalDisconnected
*/
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback );
+ void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback) override;
/**
* @brief Returns the connection count.
std::size_t GetConnectionCount() const;
private:
-
- ConnectionTracker( const ConnectionTracker& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- ConnectionTracker( ConnectionTracker&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- ConnectionTracker& operator=( const ConnectionTracker& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- ConnectionTracker& operator=( ConnectionTracker&& ) = delete;///< Deleted move assignment operator. @SINCE_1_9.25
+ ConnectionTracker(const ConnectionTracker&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ ConnectionTracker(ConnectionTracker&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ ConnectionTracker& operator=(const ConnectionTracker&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ ConnectionTracker& operator=(ConnectionTracker&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
private:
-
- Dali::Vector< SlotConnection* > mConnections; ///< Vector of connection pointers
+ Dali::Vector<SlotConnection*> mConnections; ///< Vector of connection pointers
};
/**
// INTERNAL INCLUDES
#include <dali/public-api/common/dali-common.h>
+#include <dali/public-api/signals/base-signal.h>
#include <dali/public-api/signals/callback.h>
#include <dali/public-api/signals/signal-slot-connections.h>
#include <dali/public-api/signals/slot-delegate.h>
-#include <dali/public-api/signals/base-signal.h>
namespace Dali
{
* @endcode
* @SINCE_1_0.0
*/
-template< typename _Signature >
+template<typename _Signature>
class Signal
{
};
* @brief A template for Signals with no parameters or return value.
* @SINCE_1_0.0
*/
-template <>
-class Signal< void () >
+template<>
+class Signal<void()>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( void (*func)() )
+ void Connect(void (*func)())
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( void (*func)() )
+ void Disconnect(void (*func)())
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, void (X::*func)() )
+ void Connect(X* obj, void (X::*func)())
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, void (X::*func)() )
+ void Disconnect(X* obj, void (X::*func)())
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, void (X::*func)() )
+ void Connect(SlotDelegate<X>& delegate, void (X::*func)())
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, void (X::*func)() )
+ void Disconnect(SlotDelegate<X>& delegate, void (X::*func)())
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctor0< X >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctor0<X>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegate0( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegate0(delegate));
}
/**
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< The base signal implementation
};
* @brief A template for Signals with no parameters and a return value.
* @SINCE_1_0.0
*/
-template < typename Ret >
-class Signal< Ret() >
+template<typename Ret>
+class Signal<Ret()>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( Ret (*func)() )
+ void Connect(Ret (*func)())
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( Ret (*func)() )
+ void Disconnect(Ret (*func)())
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, Ret (X::*func)() )
+ void Connect(X* obj, Ret (X::*func)())
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, Ret (X::*func)() )
+ void Disconnect(X* obj, Ret (X::*func)())
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, Ret (X::*func)() )
+ void Connect(SlotDelegate<X>& delegate, Ret (X::*func)())
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, Ret (X::*func)() )
+ void Disconnect(SlotDelegate<X>& delegate, Ret (X::*func)())
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorReturn0< X, Ret >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorReturn0<X, Ret>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegateReturn0< Ret >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegateReturn0<Ret>(delegate));
}
/**
*/
Ret Emit()
{
- return mImpl.EmitReturn< Ret >();
+ return mImpl.EmitReturn<Ret>();
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
* @brief A template for Signals with 1 parameter.
* @SINCE_1_0.0
*/
-template < typename Arg0 >
-class Signal< void ( Arg0 ) >
+template<typename Arg0>
+class Signal<void(Arg0)>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( void (*func)( Arg0 arg0 ) )
+ void Connect(void (*func)(Arg0 arg0))
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( void (*func)( Arg0 arg0 ) )
+ void Disconnect(void (*func)(Arg0 arg0))
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, void (X::*func)( Arg0 arg0 ) )
+ void Connect(X* obj, void (X::*func)(Arg0 arg0))
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, void (X::*func)( Arg0 arg0 ) )
+ void Disconnect(X* obj, void (X::*func)(Arg0 arg0))
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
+ void Connect(SlotDelegate<X>& delegate, void (X::*func)(Arg0 arg0))
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0 ) )
+ void Disconnect(SlotDelegate<X>& delegate, void (X::*func)(Arg0 arg0))
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctor1< X, Arg0 >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctor1<X, Arg0>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegate1< Arg0 >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegate1<Arg0>(delegate));
}
/**
* @SINCE_1_0.0
* @param[in] arg0 The first value to pass to callbacks
*/
- void Emit( Arg0 arg0 )
+ void Emit(Arg0 arg0)
{
- mImpl.Emit< Arg0 >( arg0 );
+ mImpl.Emit<Arg0>(arg0);
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
* @brief A template for Signals with 1 parameter and a return value.
* @SINCE_1_0.0
*/
-template < typename Ret, typename Arg0 >
-class Signal< Ret( Arg0 ) >
+template<typename Ret, typename Arg0>
+class Signal<Ret(Arg0)>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( Ret (*func)( Arg0 arg0 ) )
+ void Connect(Ret (*func)(Arg0 arg0))
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( Ret (*func)( Arg0 arg0 ) )
+ void Disconnect(Ret (*func)(Arg0 arg0))
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, Ret (X::*func)( Arg0 arg0 ) )
+ void Connect(X* obj, Ret (X::*func)(Arg0 arg0))
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, Ret (X::*func)( Arg0 arg0 ) )
+ void Disconnect(X* obj, Ret (X::*func)(Arg0 arg0))
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, Ret (X::*func)( Arg0 arg0 ) )
+ void Connect(SlotDelegate<X>& delegate, Ret (X::*func)(Arg0 arg0))
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, Ret (X::*func)( Arg0 arg0 ) )
+ void Disconnect(SlotDelegate<X>& delegate, Ret (X::*func)(Arg0 arg0))
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorReturn1< X, Arg0, Ret >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorReturn1<X, Arg0, Ret>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegateReturn1< Arg0, Ret >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegateReturn1<Arg0, Ret>(delegate));
}
/**
* @param[in] arg0 The first value to pass to callbacks
* @return The value returned by the last callback, or a default constructed value if no callbacks are connected
*/
- Ret Emit( Arg0 arg0 )
+ Ret Emit(Arg0 arg0)
{
- return mImpl.EmitReturn< Ret,Arg0 >(arg0);
+ return mImpl.EmitReturn<Ret, Arg0>(arg0);
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
*
* @SINCE_1_0.0
*/
-template < typename Arg0, typename Arg1 >
-class Signal< void ( Arg0, Arg1 ) >
+template<typename Arg0, typename Arg1>
+class Signal<void(Arg0, Arg1)>
{
public:
-
/**
* @brief Default constructor.
*
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( void (*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Connect(void (*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( void (*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Disconnect(void (*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, void (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Connect(X* obj, void (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, void (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Disconnect(X* obj, void (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Connect(SlotDelegate<X>& delegate, void (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Disconnect(SlotDelegate<X>& delegate, void (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctor2< X, Arg0, Arg1 >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctor2<X, Arg0, Arg1>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegate2< Arg0, Arg1 >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegate2<Arg0, Arg1>(delegate));
}
/**
* @param[in] arg0 The first value to pass to callbacks
* @param[in] arg1 The second value to pass to callbacks
*/
- void Emit( Arg0 arg0, Arg1 arg1 )
+ void Emit(Arg0 arg0, Arg1 arg1)
{
- mImpl.Emit< Arg0,Arg1 >( arg0, arg1 );
+ mImpl.Emit<Arg0, Arg1>(arg0, arg1);
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
* @brief A template for Signals with 2 parameters and a return value.
* @SINCE_1_0.0
*/
-template < typename Ret, typename Arg0, typename Arg1 >
-class Signal< Ret( Arg0, Arg1 ) >
+template<typename Ret, typename Arg0, typename Arg1>
+class Signal<Ret(Arg0, Arg1)>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( Ret (*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Connect(Ret (*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( Ret (*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Disconnect(Ret (*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, Ret (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Connect(X* obj, Ret (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, Ret (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Disconnect(X* obj, Ret (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, Ret (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Connect(SlotDelegate<X>& delegate, Ret (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, Ret (X::*func)( Arg0 arg0, Arg1 arg1 ) )
+ void Disconnect(SlotDelegate<X>& delegate, Ret (X::*func)(Arg0 arg0, Arg1 arg1))
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorReturn2< X, Arg0, Arg1, Ret >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorReturn2<X, Arg0, Arg1, Ret>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegateReturn2< Arg0, Arg1, Ret >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegateReturn2<Arg0, Arg1, Ret>(delegate));
}
/**
* @param[in] arg1 The second value to pass to callbacks
* @return The value returned by the last callback, or a default constructed value if no callbacks are connected
*/
- Ret Emit( Arg0 arg0, Arg1 arg1 )
+ Ret Emit(Arg0 arg0, Arg1 arg1)
{
- return mImpl.EmitReturn< Ret,Arg0,Arg1 >( arg0, arg1 );
+ return mImpl.EmitReturn<Ret, Arg0, Arg1>(arg0, arg1);
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
* @brief A template for Signals with 3 parameters.
* @SINCE_1_0.0
*/
-template < typename Arg0, typename Arg1, typename Arg2 >
-class Signal< void ( Arg0, Arg1, Arg2 ) >
+template<typename Arg0, typename Arg1, typename Arg2>
+class Signal<void(Arg0, Arg1, Arg2)>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( void (*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Connect(void (*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( void (*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Disconnect(void (*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, void (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Connect(X* obj, void (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, void (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Disconnect(X* obj, void (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Connect(SlotDelegate<X>& delegate, void (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, void (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Disconnect(SlotDelegate<X>& delegate, void (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctor3< X, Arg0, Arg1, Arg2 >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctor3<X, Arg0, Arg1, Arg2>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegate3< Arg0, Arg1, Arg2 >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegate3<Arg0, Arg1, Arg2>(delegate));
}
/**
* @param[in] arg1 The second value to pass to callbacks
* @param[in] arg2 The third value to pass to callbacks
*/
- void Emit( Arg0 arg0, Arg1 arg1, Arg2 arg2 )
+ void Emit(Arg0 arg0, Arg1 arg1, Arg2 arg2)
{
- mImpl.Emit< Arg0,Arg1,Arg2 >( arg0, arg1, arg2 );
+ mImpl.Emit<Arg0, Arg1, Arg2>(arg0, arg1, arg2);
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
* @brief A template for Signals with 2 parameters and a return value.
* @SINCE_1_0.0
*/
-template < typename Ret, typename Arg0, typename Arg1, typename Arg2 >
-class Signal< Ret( Arg0, Arg1, Arg2 ) >
+template<typename Ret, typename Arg0, typename Arg1, typename Arg2>
+class Signal<Ret(Arg0, Arg1, Arg2)>
{
public:
-
/**
* @brief Default constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] func The function to connect
*/
- void Connect( Ret (*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Connect(Ret (*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnConnect( MakeCallback( func ) );
+ mImpl.OnConnect(MakeCallback(func));
}
/**
* @SINCE_1_0.0
* @param[in] func The function to disconnect
*/
- void Disconnect( Ret (*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Disconnect(Ret (*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnDisconnect( MakeCallback( func ) );
+ mImpl.OnDisconnect(MakeCallback(func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( X* obj, Ret (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Connect(X* obj, Ret (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnConnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnConnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( X* obj, Ret (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Disconnect(X* obj, Ret (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnDisconnect( obj, MakeCallback( obj, func ) );
+ mImpl.OnDisconnect(obj, MakeCallback(obj, func));
}
/**
* @param[in] func The member function to connect
*/
template<class X>
- void Connect( SlotDelegate<X>& delegate, Ret (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Connect(SlotDelegate<X>& delegate, Ret (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnConnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnConnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The member function to disconnect
*/
template<class X>
- void Disconnect( SlotDelegate<X>& delegate, Ret (X::*func)( Arg0 arg0, Arg1 arg1, Arg2 arg2 ) )
+ void Disconnect(SlotDelegate<X>& delegate, Ret (X::*func)(Arg0 arg0, Arg1 arg1, Arg2 arg2))
{
- mImpl.OnDisconnect( delegate.GetConnectionTracker(), MakeCallback( delegate.GetSlot(), func ) );
+ mImpl.OnDisconnect(delegate.GetConnectionTracker(), MakeCallback(delegate.GetSlot(), func));
}
/**
* @param[in] func The function object to copy
*/
template<class X>
- void Connect( ConnectionTrackerInterface* connectionTracker, const X& func )
+ void Connect(ConnectionTrackerInterface* connectionTracker, const X& func)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorReturn3< X, Arg0, Arg1, Arg2, Ret >( func ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorReturn3<X, Arg0, Arg1, Arg2, Ret>(func));
}
/**
* @param[in] connectionTracker A connection tracker which can be used to disconnect
* @param[in] delegate A newly allocated FunctorDelegate (ownership is taken)
*/
- void Connect( ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate )
+ void Connect(ConnectionTrackerInterface* connectionTracker, FunctorDelegate* delegate)
{
- mImpl.OnConnect( connectionTracker, new CallbackFunctorDelegateReturn3< Arg0, Arg1, Arg2, Ret >( delegate ) );
+ mImpl.OnConnect(connectionTracker, new CallbackFunctorDelegateReturn3<Arg0, Arg1, Arg2, Ret>(delegate));
}
/**
* @param[in] arg2 The third value to pass to callbacks
* @return The value returned by the last callback, or a default constructed value if no callbacks are connected
*/
- Ret Emit( Arg0 arg0, Arg1 arg1, Arg2 arg2 )
+ Ret Emit(Arg0 arg0, Arg1 arg1, Arg2 arg2)
{
- return mImpl.EmitReturn< Ret,Arg0,Arg1,Arg2 >( arg0, arg1, arg2 );
+ return mImpl.EmitReturn<Ret, Arg0, Arg1, Arg2>(arg0, arg1, arg2);
}
private:
-
- Signal( const Signal& ) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
- Signal( Signal&& ) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
- Signal& operator=( const Signal& ) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
- Signal& operator=( Signal&& ) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
+ Signal(const Signal&) = delete; ///< Deleted copy constructor, signals don't support copying. @SINCE_1_0.0
+ Signal(Signal&&) = delete; ///< Deleted move constructor, signals don't support moving. @SINCE_1_9.25
+ Signal& operator=(const Signal&) = delete; ///< Deleted copy assignment operator @SINCE_1_0.0
+ Signal& operator=(Signal&&) = delete; ///< Deleted move assignment operator @SINCE_1_9.25
private:
-
// Use composition instead of inheritance (virtual methods don't mix well with templates)
BaseSignal mImpl; ///< Implementation
};
/*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* functions and regular functions.
* If this assert fails, please implement the template specialisation for C functions.
*/
-static_assert( sizeof(void*) == sizeof( &FunctorDispatcher<void>::Dispatch ), "Need to implement template specialisation for C functions" );
-}
+static_assert(sizeof(void*) == sizeof(&FunctorDispatcher<void>::Dispatch), "Need to implement template specialisation for C functions");
+} // namespace
FunctorDelegate::~FunctorDelegate()
{
- if( mFunctorPointer )
+ if(mFunctorPointer)
{
- (*mDestructorDispatcher)( mFunctorPointer );
+ (*mDestructorDispatcher)(mFunctorPointer);
}
}
void FunctorDelegate::Execute()
{
- if( mFunctorPointer )
+ if(mFunctorPointer)
{
Dispatcher dispatcher = mMemberFunctionDispatcher;
- (*dispatcher)( mFunctorPointer );
+ (*dispatcher)(mFunctorPointer);
}
}
-FunctorDelegate::FunctorDelegate( void* objectPtr, Dispatcher dispatcher, Destructor destructor )
-: mFunctorPointer( objectPtr ),
- mMemberFunctionDispatcher( dispatcher ),
- mDestructorDispatcher( destructor )
+FunctorDelegate::FunctorDelegate(void* objectPtr, Dispatcher dispatcher, Destructor destructor)
+: mFunctorPointer(objectPtr),
+ mMemberFunctionDispatcher(dispatcher),
+ mDestructorDispatcher(destructor)
{
}
#define DALI_FUNCTOR_DELEGATE_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
* @brief Dispatcher to call a functor.
* @SINCE_1_0.0
*/
-template< typename T >
+template<typename T>
struct FunctorDispatcher
{
/**
* @SINCE_1_0.0
* @param[in] functorPtr The functor to call
*/
- static void Dispatch( void* functorPtr )
+ static void Dispatch(void* functorPtr)
{
// "downcast" the functor type back to the correct one
- T* functor = reinterpret_cast< T* >( functorPtr );
+ T* functor = reinterpret_cast<T*>(functorPtr);
(*functor)();
}
};
* @brief Dispatcher to delete a functor object.
* @SINCE_1_0.0
*/
-template< typename T >
+template<typename T>
struct FunctorDestroyer
{
/**
* @SINCE_1_0.0
* @param[in] functorPtr A functor object to delete
*/
- static void Delete( void* functorPtr )
+ static void Delete(void* functorPtr)
{
// FunctorDelegate owns the object but we're the only one who knows the real type so need
// to delete by "downcasting" from void* to the correct type
- delete reinterpret_cast< T* >( functorPtr );
+ delete reinterpret_cast<T*>(functorPtr);
}
};
class DALI_CORE_API FunctorDelegate
{
public:
-
/**
* @brief Constructor which copies a function object.
*
* @param[in] functor The functor object to copy, either a class with operator() or a C function
* @return A pointer to the new function object
*/
- template< typename T >
- static FunctorDelegate* New( const T& functor )
+ template<typename T>
+ static FunctorDelegate* New(const T& functor)
{
- return new FunctorDelegate( reinterpret_cast< void* >( new T( functor ) ), // heap allocate the functor
- reinterpret_cast< FunctorDelegate::Dispatcher >( &FunctorDispatcher<T>::Dispatch ),
- reinterpret_cast< FunctorDelegate::Destructor >( &FunctorDestroyer<T>::Delete ) );
+ return new FunctorDelegate(reinterpret_cast<void*>(new T(functor)), // heap allocate the functor
+ reinterpret_cast<FunctorDelegate::Dispatcher>(&FunctorDispatcher<T>::Dispatch),
+ reinterpret_cast<FunctorDelegate::Destructor>(&FunctorDestroyer<T>::Delete));
}
/**
void Execute();
private:
-
/**
* @brief Used to call the correct function.
* @SINCE_1_0.0
*/
- typedef void (*Dispatcher)( void* objectPtr );
+ using Dispatcher = void (*)(void*);
/**
* @brief Used to destroy mObjectPointer.
* @SINCE_1_0.0
*/
- typedef void(*Destructor)( void* objectPtr );
+ using Destructor = void (*)(void*);
/**
* @brief Not defined.
* @SINCE_1_0.0
*/
- FunctorDelegate( const FunctorDelegate& rhs );
+ FunctorDelegate(const FunctorDelegate& rhs);
/**
* @brief Not defined.
* @SINCE_1_0.0
*/
- const FunctorDelegate& operator=( const FunctorDelegate& rhs );
+ const FunctorDelegate& operator=(const FunctorDelegate& rhs);
/**
* @brief Private constructor.
* @param dispatcher Used to call the actual function
* @param destructor Used to delete the owned functor object
*/
- FunctorDelegate( void* functorPtr, Dispatcher dispatcher, Destructor destructor );
+ FunctorDelegate(void* functorPtr, Dispatcher dispatcher, Destructor destructor);
-public: // Data for deriving classes & Dispatchers
+public:
+ // Data for deriving classes & Dispatchers
- void* mFunctorPointer; ///< Functor that will be called
+ void* mFunctorPointer; ///< Functor that will be called
Dispatcher mMemberFunctionDispatcher; ///< Dispatcher for member functions
Destructor mDestructorDispatcher; ///< Destructor for owned objects
};
/**
* @}
*/
-} // namespace DALI
+} // namespace Dali
#endif // DALI_FUNCTOR_DELEGATE_H
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
-SlotConnection::SlotConnection( SlotObserver* slotObserver, CallbackBase* callback )
-: mSlotObserver( slotObserver ),
- mCallback( callback )
+SlotConnection::SlotConnection(SlotObserver* slotObserver, CallbackBase* callback)
+: mSlotObserver(slotObserver),
+ mCallback(callback)
{
}
return mSlotObserver;
}
-SignalConnection::SignalConnection( CallbackBase* callback )
-: mSignalObserver( NULL ),
- mCallback( callback )
+SignalConnection::SignalConnection(CallbackBase* callback)
+: mSignalObserver(nullptr),
+ mCallback(callback)
{
}
-SignalConnection::SignalConnection( SignalObserver* signalObserver, CallbackBase* callback )
-: mSignalObserver( signalObserver ),
- mCallback( callback )
+SignalConnection::SignalConnection(SignalObserver* signalObserver, CallbackBase* callback)
+: mSignalObserver(signalObserver),
+ mCallback(callback)
{
}
delete mCallback;
}
-void SignalConnection::Disconnect( SlotObserver* slotObserver )
+void SignalConnection::Disconnect(SlotObserver* slotObserver)
{
- if( mSignalObserver )
+ if(mSignalObserver)
{
// tell the slot the signal wants to disconnect
- mSignalObserver->SignalDisconnected( slotObserver, mCallback );
- mSignalObserver = NULL;
+ mSignalObserver->SignalDisconnected(slotObserver, mCallback);
+ mSignalObserver = nullptr;
}
// we own the callback, SignalObserver is expected to delete the SlotConnection on Disconnected so its pointer to our mCallback is no longer used
delete mCallback;
- mCallback = NULL;
+ mCallback = nullptr;
}
CallbackBase* SignalConnection::GetCallback()
class DALI_CORE_API SlotConnection
{
public:
-
/**
* @brief Constructor.
*
SlotObserver* GetSlotObserver();
private:
-
- SlotConnection( const SlotConnection& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- SlotConnection( SlotConnection&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- SlotConnection& operator=( const SlotConnection& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- SlotConnection& operator=( SlotConnection&& ) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
+ SlotConnection(const SlotConnection&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ SlotConnection(SlotConnection&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ SlotConnection& operator=(const SlotConnection&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ SlotConnection& operator=(SlotConnection&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
private:
-
SlotObserver* mSlotObserver; ///< a pointer to the slot observer (not owned)
CallbackBase* mCallback; ///< The callback. This is not owned, the corresponding SignalConnection has ownership.
};
class DALI_CORE_API SignalConnection
{
public:
-
/**
* @brief Constructor.
*
* @SINCE_1_0.0
* @param[in] callback The callback which should be a C function
*/
- SignalConnection( CallbackBase* callback );
+ SignalConnection(CallbackBase* callback);
/**
* @brief Constructor.
* @param[in] signalObserver The signal observer
* @param[in] callback Ownership of this callback object is taken
*/
- SignalConnection( SignalObserver* signalObserver, CallbackBase* callback );
+ SignalConnection(SignalObserver* signalObserver, CallbackBase* callback);
/**
* @brief Non-virtual destructor, not intended as a base class.
* @SINCE_1_0.0
* @param[in] slotObserver The signal disconnecting from the slot
*/
- void Disconnect( SlotObserver* slotObserver );
+ void Disconnect(SlotObserver* slotObserver);
/**
* @brief Retrieves the callback.
CallbackBase* GetCallback();
private:
-
- SignalConnection( const SignalConnection& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- SignalConnection( SignalConnection&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- SignalConnection& operator=( const SignalConnection& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- SignalConnection& operator=( SignalConnection&& ) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
+ SignalConnection(const SignalConnection&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ SignalConnection(SignalConnection&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ SignalConnection& operator=(const SignalConnection&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ SignalConnection& operator=(SignalConnection&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
private:
-
SignalObserver* mSignalObserver; ///< a pointer to the signal observer (not owned)
- CallbackBase* mCallback; ///< The callback, has ownership.
+ CallbackBase* mCallback; ///< The callback, has ownership.
};
/**
/*
- * Copyright (c) 2015 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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.
namespace Dali
{
-
SignalObserver::SignalObserver()
{
}
#define DALI_SIGNAL_SLOT_OBSERVERS_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 DALI_CORE_API SignalObserver
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_0.0
* @param[in] slotObserver The signal that has disconnected
* @param[in] callback The callback attached to the signal disconnected
*/
- virtual void SignalDisconnected( SlotObserver* slotObserver, CallbackBase* callback ) = 0;
+ virtual void SignalDisconnected(SlotObserver* slotObserver, CallbackBase* callback) = 0;
};
/**
class DALI_CORE_API SlotObserver
{
public:
-
/**
* @brief Constructor.
* @SINCE_1_0.0
* @SINCE_1_0.0
* @param[in] callback The callback attached to the signal disconnected
*/
- virtual void SlotDisconnected( CallbackBase* callback ) = 0;
+ virtual void SlotDisconnected(CallbackBase* callback) = 0;
};
/**
* @endcode
* @SINCE_1_0.0
*/
-template <typename Slot>
+template<typename Slot>
class SlotDelegate
{
public:
-
/**
* @brief Constructor.
*
* @SINCE_1_0.0
* @param[in] slot The object with a callback
*/
- SlotDelegate( Slot* slot )
- : mSlot( slot )
+ SlotDelegate(Slot* slot)
+ : mSlot(slot)
{
}
}
private:
-
- SlotDelegate( const SlotDelegate& ) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
- SlotDelegate( SlotDelegate&& ) = delete; ///< Deleted move constructor. @SINCE_1_9.25
- SlotDelegate& operator=( const SlotDelegate& ) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
- SlotDelegate& operator=( SlotDelegate&& ) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
+ SlotDelegate(const SlotDelegate&) = delete; ///< Deleted copy constructor. @SINCE_1_0.0
+ SlotDelegate(SlotDelegate&&) = delete; ///< Deleted move constructor. @SINCE_1_9.25
+ SlotDelegate& operator=(const SlotDelegate&) = delete; ///< Deleted copy assignment operator. @SINCE_1_0.0
+ SlotDelegate& operator=(SlotDelegate&&) = delete; ///< Deleted move assignment operator. @SINCE_1_9.25
private:
-
Slot* mSlot; ///< The slot object
// Use composition instead of inheritance (virtual methods don't mix well with templates)
#define DALI_RELAYOUT_CONTAINER_H
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 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 RelayoutContainer;
-typedef RelayoutContainer* RelayoutContainerPtr;
-
+using RelayoutContainerPtr = RelayoutContainer*;
/**
* @brief Interface to encapsulate information required for relayout.
class RelayoutContainer
{
public:
-
/**
* @brief Default constructor.
*
* @SINCE_1_0.0
*/
- RelayoutContainer() {}
+ RelayoutContainer()
+ {
+ }
/**
* @brief Virtual destructor.
* @SINCE_1_0.0
*/
- virtual ~RelayoutContainer() {}
+ virtual ~RelayoutContainer()
+ {
+ }
/**
* @brief Adds relayout information to the container if it doesn't already exist.
* @param actor The actor to relayout
* @param size The size to relayout
*/
- virtual void Add( const Actor& actor, const Vector2& size ) = 0;
-
+ virtual void Add(const Actor& actor, const Vector2& size) = 0;
};
/**
--- /dev/null
+git diff -U0 --no-color HEAD^ | clang-format-diff -i -p1
\ No newline at end of file
Name: dali2
Summary: DALi 3D Engine
-Version: 1.9.28
+Version: 1.9.30
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-core.git / commitdiff